#include "../InternalHeaderCheck.h"
#include <cmath>

Namespaces
	Eigen
	Namespace containing all symbols from the Eigen library.

	Eigen::internal
	Namespace containing low-level routines from the Eigen library.

Macros
#define	EIGEN_WORLD_VERSION 3

#define	EIGEN_MAJOR_VERSION 4

#define	EIGEN_MINOR_VERSION 90

#define	EIGEN_VERSION_AT_LEAST(x, y, z)

#define	EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor

#define	EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t

#define	EIGEN_MAX_CPP_VER 99

#define	EIGEN_FAST_MATH 1

#define	EIGEN_STACK_ALLOCATION_LIMIT 131072

#define	EIGEN_COMP_GNUC 0

#define	EIGEN_COMP_CLANG 0

#define	EIGEN_COMP_CLANGAPPLE 0

#define	EIGEN_COMP_CASTXML 0

#define	EIGEN_COMP_LLVM 0

#define	EIGEN_COMP_ICC 0

#define	EIGEN_COMP_CLANGICC 0

#define	EIGEN_COMP_MINGW 0

#define	EIGEN_COMP_SUNCC 0

#define	EIGEN_COMP_MSVC 0

#define	EIGEN_COMP_NVCC 0

#define	EIGEN_COMP_MSVC_LANG 0

#define	EIGEN_COMP_MSVC_STRICT 0

#define	EIGEN_COMP_IBM 0

#define	EIGEN_COMP_PGI 0

#define	EIGEN_COMP_NVHPC 0

#define	EIGEN_COMP_ARM 0

#define	EIGEN_COMP_EMSCRIPTEN 0

#define	EIGEN_COMP_FCC 0

#define	EIGEN_COMP_CLANGFCC 0

#define	EIGEN_COMP_CPE 0

#define	EIGEN_COMP_CLANGCPE 0

#define	EIGEN_COMP_LCC 0

#define	EIGEN_COMP_GNUC_STRICT 0

#define	EIGEN_GNUC_STRICT_AT_LEAST(x, y, z) 0

#define	EIGEN_GNUC_STRICT_LESS_THAN(x, y, z) 0

#define	EIGEN_COMP_CLANG_STRICT 0

#define	EIGEN_CLANG_STRICT_AT_LEAST(x, y, z) 0

#define	EIGEN_CLANG_STRICT_LESS_THAN(x, y, z) 0

#define	EIGEN_ARCH_x86_64 0

#define	EIGEN_ARCH_i386 0

#define	EIGEN_ARCH_i386_OR_x86_64 0

#define	EIGEN_ARCH_ARM 0

#define	EIGEN_ARCH_ARM64 0

#define	EIGEN_ARCH_ARM_OR_ARM64 0

#define	EIGEN_ARCH_ARMV8 0

#define	EIGEN_ARCH_MIPS 0

#define	EIGEN_ARCH_LOONGARCH64 0

#define	EIGEN_ARCH_SPARC 0

#define	EIGEN_ARCH_IA64 0

#define	EIGEN_ARCH_PPC 0

#define	EIGEN_OS_UNIX 0

#define	EIGEN_OS_LINUX 0

#define	EIGEN_OS_ANDROID 0

#define	EIGEN_OS_GNULINUX 0

#define	EIGEN_OS_BSD 0

#define	EIGEN_OS_MAC 0

#define	EIGEN_OS_QNX 0

#define	EIGEN_OS_WIN 0

#define	EIGEN_OS_WIN64 0

#define	EIGEN_OS_WINCE 0

#define	EIGEN_OS_CYGWIN 0

#define	EIGEN_OS_WIN_STRICT 0

#define	EIGEN_OS_SUN 0

#define	EIGEN_OS_SOLARIS 0

#define	EIGEN_CUDA_SDK_VER 0

#define	EIGEN_HIP_LAUNCH_BOUNDS_1024

#define	EIGEN_HAS_BUILTIN(x) 0

#define	__has_feature(x) 0

#define	EIGEN_CPLUSPLUS 0

#define	EIGEN_COMP_CXXVER 03

#define	EIGEN_HAS_C99_MATH 0

#define	EIGEN_HAS_STD_HASH 1

#define	EIGEN_HAS_STD_INVOKE_RESULT 0

#define	EIGEN_CONSTEXPR constexpr

#define	EIGEN_HAS_CXX17_OVERALIGN 0

#define	EIGEN_HAS_BUILTIN_INT128 0

#define	EIGEN_NOT_A_MACRO

#define	EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;

#define	EIGEN_CAT2(a, b) a##b

#define	EIGEN_CAT(a, b) EIGEN_CAT2(a, b)

#define	EIGEN_COMMA ,

#define	EIGEN_MAKESTRING2(a) #a

#define	EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)

#define	EIGEN_STRONG_INLINE inline

#define	EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE

#define	EIGEN_DONT_INLINE

#define	EIGEN_PERMISSIVE_EXPR

#define	EIGEN_DEVICE_FUNC

#define	EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC

#define	EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC inline

#define	eigen_assert(x) eigen_plain_assert(x)

#define	eigen_internal_assert(x) ((void)0)

#define	EIGEN_ONLY_USED_FOR_DEBUG(x)

#define	EIGEN_DEPRECATED

#define	EIGEN_UNUSED

#define	EIGEN_PRAGMA(tokens)

#define	EIGEN_DIAGNOSTICS(tokens)

#define	EIGEN_DIAGNOSTICS_OFF(msc, gcc)

#define	EIGEN_DISABLE_DEPRECATED_WARNING EIGEN_DIAGNOSTICS_OFF(disable : 4996, ignored "-Wdeprecated-declarations")

#define	EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var);

#define	EIGEN_ASM_COMMENT(X)

#define	EIGEN_OPTIMIZATION_BARRIER(X)

#define	EIGEN_CONST_CONDITIONAL(cond) cond

#define	EIGEN_RESTRICT __restrict

#define	EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()

#define	EIGEN_EMPTY

#define	EIGEN_USING_STD(FUNC) using std::FUNC;

#define	EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)

#define	EIGEN_DEFAULT_COPY_CONSTRUCTOR(CLASS) EIGEN_DEVICE_FUNC CLASS(const CLASS&) = default;
	Macro to explicitly define the default copy constructor. This is necessary, because the implicit definition is deprecated if the copy-assignment is overridden. More...

#define	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
	Macro to manually inherit assignment operators. This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined. With C++11 or later this also default-implements the copy-constructor. More...

#define	EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)
	Macro to manually define default constructors and destructors. This is necessary when the copy constructor is re-defined. For empty helper classes this should usually be protected, to avoid accidentally creating empty objects. More...

#define	EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)

#define	EIGEN_DENSE_PUBLIC_INTERFACE(Derived)

#define	EIGEN_PREDICT_FALSE(x) (x)

#define	EIGEN_PREDICT_TRUE(x) (x)

#define	EIGEN_CWISE_BINARY_RETURN_TYPE(LHS, RHS, OPNAME)

#define	EIGEN_MAKE_CWISE_BINARY_OP(METHOD, OPNAME)

#define	EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, TYPEA, TYPEB)

#define	EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR, SCALAR, OPNAME)

#define	EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, OPNAME)

#define	EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, OPNAME)

#define	EIGEN_MAKE_SCALAR_BINARY_OP(METHOD, OPNAME)

#define	EIGEN_THROW_X(X) std::abort()

#define	EIGEN_THROW std::abort()

#define	EIGEN_TRY if (true)

#define	EIGEN_CATCH(X) else

#define	EIGEN_NOEXCEPT noexcept

#define	EIGEN_NOEXCEPT_IF(x) noexcept(x)

#define	EIGEN_NO_THROW noexcept(true)

#define	EIGEN_EXCEPTION_SPEC(X) noexcept(false)

#define	EIGEN_OVERRIDE override

#define	EIGEN_FINAL final

#define	EIGEN_UNROLL_LOOP

#define	EIGEN_IF_CONSTEXPR(X) if (X)

Functions
template<typename T >
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void	Eigen::internal::ignore_unused_variable (const T &)

EIGEN_DEVICE_FUNC bool	Eigen::internal::all ()

template<typename T , typename... Ts>
EIGEN_DEVICE_FUNC bool	Eigen::internal::all (T t, Ts... ts)

Macro Definition Documentation

◆ __has_feature

#define __has_feature ( x ) 0

◆ EIGEN_ALWAYS_INLINE

#define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE

◆ EIGEN_ARCH_ARM

#define EIGEN_ARCH_ARM 0

EIGEN_ARCH_ARM set to 1 if the architecture is ARM

◆ EIGEN_ARCH_ARM64

#define EIGEN_ARCH_ARM64 0

EIGEN_ARCH_ARM64 set to 1 if the architecture is ARM64

◆ EIGEN_ARCH_ARM_OR_ARM64

#define EIGEN_ARCH_ARM_OR_ARM64 0

EIGEN_ARCH_ARM_OR_ARM64 set to 1 if the architecture is ARM or ARM64

◆ EIGEN_ARCH_ARMV8

#define EIGEN_ARCH_ARMV8 0

EIGEN_ARCH_ARMV8 set to 1 if the architecture is armv8 or greater.

◆ EIGEN_ARCH_i386

#define EIGEN_ARCH_i386 0

◆ EIGEN_ARCH_i386_OR_x86_64

#define EIGEN_ARCH_i386_OR_x86_64 0

◆ EIGEN_ARCH_IA64

#define EIGEN_ARCH_IA64 0

EIGEN_ARCH_IA64 set to 1 if the architecture is Intel Itanium

◆ EIGEN_ARCH_LOONGARCH64

#define EIGEN_ARCH_LOONGARCH64 0

EIGEN_ARCH_LOONGARCH64 set to 1 if the architecture is LOONGARCH64

◆ EIGEN_ARCH_MIPS

#define EIGEN_ARCH_MIPS 0

EIGEN_HAS_ARM64_FP16 set to 1 if the architecture provides an IEEE compliant Arm fp16 type

EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS

◆ EIGEN_ARCH_PPC

#define EIGEN_ARCH_PPC 0

EIGEN_ARCH_PPC set to 1 if the architecture is PowerPC

◆ EIGEN_ARCH_SPARC

#define EIGEN_ARCH_SPARC 0

EIGEN_ARCH_SPARC set to 1 if the architecture is SPARC

◆ EIGEN_ARCH_x86_64

#define EIGEN_ARCH_x86_64 0

◆ EIGEN_ASM_COMMENT

#define EIGEN_ASM_COMMENT ( X )

◆ eigen_assert

#define eigen_assert ( x ) eigen_plain_assert(x)

◆ EIGEN_CAT

#define EIGEN_CAT	(	a,
		b
	)	EIGEN_CAT2(a, b)

◆ EIGEN_CAT2

#define EIGEN_CAT2	(	a,
		b
	)	a##b

◆ EIGEN_CATCH

#define EIGEN_CATCH ( X ) else

◆ EIGEN_CLANG_STRICT_AT_LEAST

#define EIGEN_CLANG_STRICT_AT_LEAST	(	x,
		y,
		z
	)	0

◆ EIGEN_CLANG_STRICT_LESS_THAN

#define EIGEN_CLANG_STRICT_LESS_THAN	(	x,
		y,
		z
	)	0

◆ EIGEN_COMMA

#define EIGEN_COMMA ,

◆ EIGEN_COMP_ARM

#define EIGEN_COMP_ARM 0

EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler

◆ EIGEN_COMP_CASTXML

#define EIGEN_COMP_CASTXML 0

EIGEN_COMP_CASTXML set to 1 if being preprocessed by CastXML

◆ EIGEN_COMP_CLANG

#define EIGEN_COMP_CLANG 0

EIGEN_COMP_CLANG set to version (e.g., 372 for clang 3.7.2) if the compiler is clang

◆ EIGEN_COMP_CLANG_STRICT

#define EIGEN_COMP_CLANG_STRICT 0

EIGEN_COMP_CLANG_STRICT set to 1 if the compiler is really Clang and not a compatible compiler (e.g., AppleClang, etc.)

◆ EIGEN_COMP_CLANGAPPLE

#define EIGEN_COMP_CLANGAPPLE 0

EIGEN_COMP_CLANGAPPLE set to the version number (e.g. 9000000 for AppleClang 9.0) if the compiler is AppleClang

◆ EIGEN_COMP_CLANGCPE

#define EIGEN_COMP_CLANGCPE 0

EIGEN_COMP_CLANGCPE set to CPE version if the compiler is HPE Cray Compiler (Clang based)

Note: This is the C/C++ compiler from the HPE Cray Programming Environment (CPE) based on Cray Clang 11.0 without SVE-support

◆ EIGEN_COMP_CLANGFCC

#define EIGEN_COMP_CLANGFCC 0

EIGEN_COMP_CLANGFCC set to FCC version if the compiler is Fujitsu Compiler (Clang mode)

Note: The Fujitsu C/C++ compiler uses the non-traditional mode based on Clang 7.1.0 if invoked with the -Nclang flag

◆ EIGEN_COMP_CLANGICC

#define EIGEN_COMP_CLANGICC 0

EIGEN_COMP_CLANGICC set to __INTEL_CLANG_COMPILER if the compiler is Intel icx compiler, 0 otherwise

◆ EIGEN_COMP_CPE

#define EIGEN_COMP_CPE 0

EIGEN_COMP_CPE set to CPE version if the compiler is HPE Cray Compiler (GCC based)

Note: This is the SVE-enabled C/C++ compiler from the HPE Cray Programming Environment (CPE) based on Cray GCC 8.1

◆ EIGEN_COMP_CXXVER

#define EIGEN_COMP_CXXVER 03

◆ EIGEN_COMP_EMSCRIPTEN

#define EIGEN_COMP_EMSCRIPTEN 0

EIGEN_COMP_EMSCRIPTEN set to 1 if the compiler is Emscripten Compiler

◆ EIGEN_COMP_FCC

#define EIGEN_COMP_FCC 0

EIGEN_COMP_FCC set to FCC version if the compiler is Fujitsu Compiler (traditional mode)

Note: The Fujitsu C/C++ compiler uses the traditional mode based on EDG g++ 6.1 by default or if invoked with the -Nnoclang flag

◆ EIGEN_COMP_GNUC

#define EIGEN_COMP_GNUC 0

EIGEN_COMP_GNUC set to version (e.g., 951 for GCC 9.5.1) for all compilers compatible with GCC

◆ EIGEN_COMP_GNUC_STRICT

#define EIGEN_COMP_GNUC_STRICT 0

EIGEN_COMP_GNUC_STRICT set to 1 if the compiler is really GCC and not a compatible compiler (e.g., ICC, clang, mingw, etc.)

◆ EIGEN_COMP_IBM

#define EIGEN_COMP_IBM 0

EIGEN_COMP_IBM set to xlc version if the compiler is IBM XL C++

◆ EIGEN_COMP_ICC

#define EIGEN_COMP_ICC 0

EIGEN_COMP_ICC set to __INTEL_COMPILER if the compiler is Intel icc compiler, 0 otherwise

◆ EIGEN_COMP_LCC

#define EIGEN_COMP_LCC 0

EIGEN_COMP_LCC set to 1 if the compiler is MCST-LCC (MCST eLbrus Compiler Collection)

◆ EIGEN_COMP_LLVM

#define EIGEN_COMP_LLVM 0

EIGEN_COMP_LLVM set to 1 if the compiler backend is llvm

◆ EIGEN_COMP_MINGW

#define EIGEN_COMP_MINGW 0

EIGEN_COMP_MINGW set to 1 if the compiler is mingw

◆ EIGEN_COMP_MSVC

#define EIGEN_COMP_MSVC 0

EIGEN_COMP_MSVC set to _MSC_VER if the compiler is Microsoft Visual C++, 0 otherwise.

◆ EIGEN_COMP_MSVC_LANG

#define EIGEN_COMP_MSVC_LANG 0

EIGEN_COMP_MSVC_LANG set to _MSVC_LANG if the compiler is Microsoft Visual C++, 0 otherwise.

◆ EIGEN_COMP_MSVC_STRICT

#define EIGEN_COMP_MSVC_STRICT 0

EIGEN_COMP_MSVC_STRICT set to 1 if the compiler is really Microsoft Visual C++ and not ,e.g., ICC or clang-cl

◆ EIGEN_COMP_NVCC

#define EIGEN_COMP_NVCC 0

◆ EIGEN_COMP_NVHPC

#define EIGEN_COMP_NVHPC 0

EIGEN_COMP_NVHPC set to NVHPC version if the compiler is nvc++

◆ EIGEN_COMP_PGI

#define EIGEN_COMP_PGI 0

EIGEN_COMP_PGI set to PGI version if the compiler is Portland Group Compiler

◆ EIGEN_COMP_SUNCC

#define EIGEN_COMP_SUNCC 0

EIGEN_COMP_SUNCC set to 1 if the compiler is Solaris Studio

◆ EIGEN_CONST_CONDITIONAL

#define EIGEN_CONST_CONDITIONAL ( cond ) cond

◆ EIGEN_CONSTEXPR

#define EIGEN_CONSTEXPR constexpr

◆ EIGEN_CPLUSPLUS

#define EIGEN_CPLUSPLUS 0

◆ EIGEN_CUDA_SDK_VER

#define EIGEN_CUDA_SDK_VER 0

◆ EIGEN_CWISE_BINARY_RETURN_TYPE

#define EIGEN_CWISE_BINARY_RETURN_TYPE	(	LHS,
		RHS,
		OPNAME
	)

Value:

  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_, OPNAME), _op) < typename internal::traits<LHS>::Scalar, \
                typename internal::traits<RHS>::Scalar>,                                                       \
      const LHS, const RHS >

◆ EIGEN_DEBUG_VAR

#define EIGEN_DEBUG_VAR ( x ) std::cerr << #x << " = " << x << std::endl;

◆ EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS

#define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC

◆ EIGEN_DEFAULT_COPY_CONSTRUCTOR

#define EIGEN_DEFAULT_COPY_CONSTRUCTOR ( CLASS ) EIGEN_DEVICE_FUNC CLASS(const CLASS&) = default;

Macro to explicitly define the default copy constructor. This is necessary, because the implicit definition is deprecated if the copy-assignment is overridden.

◆ EIGEN_DEFAULT_DENSE_INDEX_TYPE

#define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t

◆ EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR

#define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR ( Derived )

Value:

EIGEN_DEVICE_FUNC Derived() = default; \

EIGEN_DEVICE_FUNC ~Derived() = default;

EIGEN_DEVICE_FUNC

#define EIGEN_DEVICE_FUNC

Definition: Macros.h:892

Macro to manually define default constructors and destructors. This is necessary when the copy constructor is re-defined. For empty helper classes this should usually be protected, to avoid accidentally creating empty objects.

Hiding the default destructor lead to problems in C++03 mode together with boost::multiprecision

◆ EIGEN_DEFAULT_IO_FORMAT

#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()

◆ EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION

#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor

◆ EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS

#define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC inline

◆ EIGEN_DENSE_PUBLIC_INTERFACE

#define EIGEN_DENSE_PUBLIC_INTERFACE ( Derived )

Value:

EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \

typedef typename Base::PacketScalar PacketScalar;

EIGEN_GENERIC_PUBLIC_INTERFACE

#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)

Definition: Macros.h:1149

◆ EIGEN_DEPRECATED

#define EIGEN_DEPRECATED

◆ EIGEN_DEVICE_FUNC

#define EIGEN_DEVICE_FUNC

Examples: /home/plath/mercurydpm2/mercurydpm/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

◆ EIGEN_DIAGNOSTICS

#define EIGEN_DIAGNOSTICS ( tokens )

◆ EIGEN_DIAGNOSTICS_OFF

#define EIGEN_DIAGNOSTICS_OFF	(	msc,
		gcc
	)

◆ EIGEN_DISABLE_DEPRECATED_WARNING

#define EIGEN_DISABLE_DEPRECATED_WARNING EIGEN_DIAGNOSTICS_OFF(disable : 4996, ignored "-Wdeprecated-declarations")

◆ EIGEN_DONT_INLINE

#define EIGEN_DONT_INLINE

◆ EIGEN_EMPTY

#define EIGEN_EMPTY

◆ EIGEN_EXCEPTION_SPEC

#define EIGEN_EXCEPTION_SPEC ( X ) noexcept(false)

◆ EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE

#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE	(	EXPR,
		SCALAR,
		OPNAME
	)

Value:

  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_, OPNAME), _op) < typename internal::traits<EXPR>::Scalar, \
                SCALAR>,                                                                                        \
      const EXPR, const typename internal::plain_constant_type<EXPR, SCALAR>::type >

◆ EIGEN_FAST_MATH

#define EIGEN_FAST_MATH 1

Allows to disable some optimizations which might affect the accuracy of the result. Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them. They currently include:

single precision ArrayBase::sin() and ArrayBase::cos() for SSE and AVX vectorization.

◆ EIGEN_FINAL

#define EIGEN_FINAL final

◆ EIGEN_GENERIC_PUBLIC_INTERFACE

#define EIGEN_GENERIC_PUBLIC_INTERFACE ( Derived )

Value:

  typedef typename Eigen::internal::traits<Derived>::Scalar                                                            \
      Scalar;                              \
  typedef typename Eigen::NumTraits<Scalar>::Real                                                                      \
      RealScalar;                                       \
  typedef typename Base::CoeffReturnType                                                                               \
      CoeffReturnType;                \
  typedef typename Eigen::internal::ref_selector<Derived>::type Nested;                                                \
  typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind;                                          \
  typedef typename Eigen::internal::traits<Derived>::StorageIndex StorageIndex;                                        \
  enum CompileTimeTraits {                                                                                             \
    RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime,                                           \
    ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime,                                           \
    Flags = Eigen::internal::traits<Derived>::Flags,                                                                   \
    SizeAtCompileTime = Base::SizeAtCompileTime,                                                                       \
    MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime,                                                                 \
    IsVectorAtCompileTime = Base::IsVectorAtCompileTime                                                                \
  };                                                                                                                   \
  using Base::derived;                                                                                                 \
  using Base::const_cast_derived;

Just a side note. Commenting within defines works only by documenting behind the object (via '!<'). Comments cannot be multi-line and thus we have these extra long lines. What is confusing doxygen over here is that we use '\' and basically have a bunch of typedefs with their documentation in a single line.

◆ EIGEN_GNUC_STRICT_AT_LEAST

#define EIGEN_GNUC_STRICT_AT_LEAST	(	x,
		y,
		z
	)	0

◆ EIGEN_GNUC_STRICT_LESS_THAN

#define EIGEN_GNUC_STRICT_LESS_THAN	(	x,
		y,
		z
	)	0

◆ EIGEN_HAS_BUILTIN

#define EIGEN_HAS_BUILTIN ( x ) 0

EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC set to 1 if the architecture supports Neon vector intrinsics for fp16.

EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC set to 1 if the architecture supports Neon scalar intrinsics for fp16.

◆ EIGEN_HAS_BUILTIN_INT128

#define EIGEN_HAS_BUILTIN_INT128 0

◆ EIGEN_HAS_C99_MATH

#define EIGEN_HAS_C99_MATH 0

◆ EIGEN_HAS_CXX17_OVERALIGN

#define EIGEN_HAS_CXX17_OVERALIGN 0

◆ EIGEN_HAS_STD_HASH

#define EIGEN_HAS_STD_HASH 1

◆ EIGEN_HAS_STD_INVOKE_RESULT

#define EIGEN_HAS_STD_INVOKE_RESULT 0

◆ EIGEN_HIP_LAUNCH_BOUNDS_1024

#define EIGEN_HIP_LAUNCH_BOUNDS_1024

◆ EIGEN_IF_CONSTEXPR

#define EIGEN_IF_CONSTEXPR ( X ) if (X)

◆ EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR

#define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR ( Derived )

Value:

  using Base::operator=;                                                           \
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) { \
    Base::operator=(other);                                                        \
    return *this;                                                                  \
  }

◆ EIGEN_INHERIT_ASSIGNMENT_OPERATORS

#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS ( Derived )

Value:

EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \

EIGEN_DEFAULT_COPY_CONSTRUCTOR(Derived)

EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR

#define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)

Definition: Macros.h:1106

Macro to manually inherit assignment operators. This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined. With C++11 or later this also default-implements the copy-constructor.

◆ eigen_internal_assert

#define eigen_internal_assert ( x ) ((void)0)

◆ EIGEN_MAJOR_VERSION

#define EIGEN_MAJOR_VERSION 4

◆ EIGEN_MAKE_CWISE_BINARY_OP

#define EIGEN_MAKE_CWISE_BINARY_OP	(	METHOD,
		OPNAME
	)

Value:

  template <typename OtherDerived>                                                                                \
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(                                     \
      Derived, OtherDerived, OPNAME)(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived>& other) const { \
    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, OPNAME)(derived(), other.derived());             \
  }

◆ EIGEN_MAKE_SCALAR_BINARY_OP

#define EIGEN_MAKE_SCALAR_BINARY_OP	(	METHOD,
		OPNAME
	)

Value:

EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, OPNAME) \

EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, OPNAME)

EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT

#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, OPNAME)

Definition: Macros.h:1224

◆ EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT

#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT	(	METHOD,
		OPNAME
	)

Value:

  template <typename T>                                                                                              \
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(                         \
      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(          \
          OPNAME, T, Scalar)>::type,                                                                                 \
      Derived, OPNAME)(METHOD)(const T& scalar, const StorageBaseType& matrix) {                                     \
    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, T, Scalar)>::type \
        PromotedT;                                                                                                   \
    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT, Derived, OPNAME)(                                       \
        typename internal::plain_constant_type<Derived, PromotedT>::type(                                            \
            matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)),      \
        matrix.derived());                                                                                           \
  }

◆ EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT

#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT	(	METHOD,
		OPNAME
	)

Value:

  template <typename T>                                                                                              \
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(                                \
      Derived,                                                                                                       \
      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(          \
          OPNAME, Scalar, T)>::type,                                                                                 \
      OPNAME)(METHOD)(const T& scalar) const {                                                                       \
    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, Scalar, T)>::type \
        PromotedT;                                                                                                   \
    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, PromotedT, OPNAME)(                                       \
        derived(), typename internal::plain_constant_type<Derived, PromotedT>::type(                                 \
                       derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)));        \
  }

◆ EIGEN_MAKESTRING

#define EIGEN_MAKESTRING ( a ) EIGEN_MAKESTRING2(a)

◆ EIGEN_MAKESTRING2

#define EIGEN_MAKESTRING2 ( a ) #a

◆ EIGEN_MAX_CPP_VER

#define EIGEN_MAX_CPP_VER 99

◆ EIGEN_MINOR_VERSION

#define EIGEN_MINOR_VERSION 90

◆ EIGEN_NO_THROW

#define EIGEN_NO_THROW noexcept(true)

◆ EIGEN_NOEXCEPT

#define EIGEN_NOEXCEPT noexcept

◆ EIGEN_NOEXCEPT_IF

#define EIGEN_NOEXCEPT_IF ( x ) noexcept(x)

◆ EIGEN_NOT_A_MACRO

#define EIGEN_NOT_A_MACRO

◆ EIGEN_ONLY_USED_FOR_DEBUG

#define EIGEN_ONLY_USED_FOR_DEBUG ( x )

◆ EIGEN_OPTIMIZATION_BARRIER

#define EIGEN_OPTIMIZATION_BARRIER ( X )

◆ EIGEN_OS_ANDROID

#define EIGEN_OS_ANDROID 0

EIGEN_OS_ANDROID set to 1 if the OS is Android

◆ EIGEN_OS_BSD

#define EIGEN_OS_BSD 0

EIGEN_OS_BSD set to 1 if the OS is a BSD variant

◆ EIGEN_OS_CYGWIN

#define EIGEN_OS_CYGWIN 0

EIGEN_OS_CYGWIN set to 1 if the OS is Windows/Cygwin

◆ EIGEN_OS_GNULINUX

#define EIGEN_OS_GNULINUX 0

EIGEN_OS_GNULINUX set to 1 if the OS is GNU Linux and not Linux-based OS (e.g., not android)

◆ EIGEN_OS_LINUX

#define EIGEN_OS_LINUX 0

EIGEN_OS_LINUX set to 1 if the OS is based on Linux kernel

◆ EIGEN_OS_MAC

#define EIGEN_OS_MAC 0

EIGEN_OS_MAC set to 1 if the OS is MacOS

◆ EIGEN_OS_QNX

#define EIGEN_OS_QNX 0

EIGEN_OS_QNX set to 1 if the OS is QNX

◆ EIGEN_OS_SOLARIS

#define EIGEN_OS_SOLARIS 0

EIGEN_OS_SOLARIS set to 1 if the OS is Solaris

◆ EIGEN_OS_SUN

#define EIGEN_OS_SUN 0

EIGEN_OS_SUN set to __SUNPRO_C if the OS is SUN

◆ EIGEN_OS_UNIX

#define EIGEN_OS_UNIX 0

EIGEN_OS_UNIX set to 1 if the OS is a unix variant

◆ EIGEN_OS_WIN

#define EIGEN_OS_WIN 0

EIGEN_OS_WIN set to 1 if the OS is Windows based

◆ EIGEN_OS_WIN64

#define EIGEN_OS_WIN64 0

EIGEN_OS_WIN64 set to 1 if the OS is Windows 64bits

◆ EIGEN_OS_WIN_STRICT

#define EIGEN_OS_WIN_STRICT 0

EIGEN_OS_WIN_STRICT set to 1 if the OS is really Windows and not some variants

◆ EIGEN_OS_WINCE

#define EIGEN_OS_WINCE 0

EIGEN_OS_WINCE set to 1 if the OS is Windows CE

◆ EIGEN_OVERRIDE

#define EIGEN_OVERRIDE override

◆ EIGEN_PERMISSIVE_EXPR

#define EIGEN_PERMISSIVE_EXPR

◆ EIGEN_PRAGMA

#define EIGEN_PRAGMA ( tokens )

◆ EIGEN_PREDICT_FALSE

#define EIGEN_PREDICT_FALSE ( x ) (x)

◆ EIGEN_PREDICT_TRUE

#define EIGEN_PREDICT_TRUE ( x ) (x)

◆ EIGEN_RESTRICT

#define EIGEN_RESTRICT __restrict

◆ EIGEN_SCALAR_BINARY_SUPPORTED

#define EIGEN_SCALAR_BINARY_SUPPORTED	(	OPNAME,
		TYPEA,
		TYPEB
	)

Value:

(Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits< \

TYPEA, TYPEB, EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_, OPNAME), _op) < TYPEA, TYPEB> > > ::value)

Eigen::value

squared absolute value

Definition: GlobalFunctions.h:87

Eigen::ScalarBinaryOpTraits

Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...

Definition: XprHelper.h:1043

Eigen::internal::has_ReturnType

Definition: Meta.h:419

◆ EIGEN_STACK_ALLOCATION_LIMIT

#define EIGEN_STACK_ALLOCATION_LIMIT 131072

◆ EIGEN_STRONG_INLINE

#define EIGEN_STRONG_INLINE inline

Examples: /home/plath/mercurydpm2/mercurydpm/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

◆ EIGEN_THROW

#define EIGEN_THROW std::abort()

◆ EIGEN_THROW_X

#define EIGEN_THROW_X ( X ) std::abort()

◆ EIGEN_TRY

#define EIGEN_TRY if (true)

◆ EIGEN_UNROLL_LOOP

#define EIGEN_UNROLL_LOOP

◆ EIGEN_UNUSED

#define EIGEN_UNUSED

◆ EIGEN_UNUSED_VARIABLE

#define EIGEN_UNUSED_VARIABLE ( var ) Eigen::internal::ignore_unused_variable(var);

◆ EIGEN_USING_STD

#define EIGEN_USING_STD ( FUNC ) using std::FUNC;

◆ EIGEN_VERSION_AT_LEAST

#define EIGEN_VERSION_AT_LEAST	(	x,
		y,
		z
	)

Value:

(EIGEN_WORLD_VERSION > x || \

(EIGEN_WORLD_VERSION >= x && (EIGEN_MAJOR_VERSION > y || (EIGEN_MAJOR_VERSION >= y && EIGEN_MINOR_VERSION >= z))))

EIGEN_MINOR_VERSION

#define EIGEN_MINOR_VERSION

Definition: Macros.h:22

EIGEN_MAJOR_VERSION

#define EIGEN_MAJOR_VERSION

Definition: Macros.h:21

EIGEN_WORLD_VERSION

#define EIGEN_WORLD_VERSION

Definition: Macros.h:20

y

Scalar * y

Definition: level1_cplx_impl.h:128

plotDoE.x

list x

Definition: plotDoE.py:28

◆ EIGEN_WORLD_VERSION

#define EIGEN_WORLD_VERSION 3

Namespaces

Macros

Functions

Macro Definition Documentation

◆ __has_feature

◆ EIGEN_ALWAYS_INLINE

◆ EIGEN_ARCH_ARM

◆ EIGEN_ARCH_ARM64

◆ EIGEN_ARCH_ARM_OR_ARM64

◆ EIGEN_ARCH_ARMV8

◆ EIGEN_ARCH_i386

◆ EIGEN_ARCH_i386_OR_x86_64

◆ EIGEN_ARCH_IA64

◆ EIGEN_ARCH_LOONGARCH64

◆ EIGEN_ARCH_MIPS

◆ EIGEN_ARCH_PPC

◆ EIGEN_ARCH_SPARC

◆ EIGEN_ARCH_x86_64

◆ EIGEN_ASM_COMMENT

◆ eigen_assert

◆ EIGEN_CAT

◆ EIGEN_CAT2

◆ EIGEN_CATCH

◆ EIGEN_CLANG_STRICT_AT_LEAST

◆ EIGEN_CLANG_STRICT_LESS_THAN

◆ EIGEN_COMMA

◆ EIGEN_COMP_ARM

◆ EIGEN_COMP_CASTXML

◆ EIGEN_COMP_CLANG

◆ EIGEN_COMP_CLANG_STRICT

◆ EIGEN_COMP_CLANGAPPLE

◆ EIGEN_COMP_CLANGCPE

◆ EIGEN_COMP_CLANGFCC

◆ EIGEN_COMP_CLANGICC

◆ EIGEN_COMP_CPE

◆ EIGEN_COMP_CXXVER

◆ EIGEN_COMP_EMSCRIPTEN

◆ EIGEN_COMP_FCC

◆ EIGEN_COMP_GNUC

◆ EIGEN_COMP_GNUC_STRICT

◆ EIGEN_COMP_IBM

◆ EIGEN_COMP_ICC

◆ EIGEN_COMP_LCC

◆ EIGEN_COMP_LLVM

◆ EIGEN_COMP_MINGW

◆ EIGEN_COMP_MSVC

◆ EIGEN_COMP_MSVC_LANG

◆ EIGEN_COMP_MSVC_STRICT

◆ EIGEN_COMP_NVCC

◆ EIGEN_COMP_NVHPC

◆ EIGEN_COMP_PGI

◆ EIGEN_COMP_SUNCC

◆ EIGEN_CONST_CONDITIONAL

◆ EIGEN_CONSTEXPR

◆ EIGEN_CPLUSPLUS

◆ EIGEN_CUDA_SDK_VER

◆ EIGEN_CWISE_BINARY_RETURN_TYPE

◆ EIGEN_DEBUG_VAR

◆ EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS

◆ EIGEN_DEFAULT_COPY_CONSTRUCTOR

◆ EIGEN_DEFAULT_DENSE_INDEX_TYPE

◆ EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR

◆ EIGEN_DEFAULT_IO_FORMAT

◆ EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION

◆ EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS

◆ EIGEN_DENSE_PUBLIC_INTERFACE

◆ EIGEN_DEPRECATED

◆ EIGEN_DEVICE_FUNC

◆ EIGEN_DIAGNOSTICS

◆ EIGEN_DIAGNOSTICS_OFF

◆ EIGEN_DISABLE_DEPRECATED_WARNING

◆ EIGEN_DONT_INLINE

◆ EIGEN_EMPTY

◆ EIGEN_EXCEPTION_SPEC

◆ EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE

◆ EIGEN_FAST_MATH

◆ EIGEN_FINAL

◆ EIGEN_GENERIC_PUBLIC_INTERFACE

◆ EIGEN_GNUC_STRICT_AT_LEAST

◆ EIGEN_GNUC_STRICT_LESS_THAN