Macros.h File Reference

#include <cmath>

Go to the source code of this file.

Namespaces
namespace	Eigen
	Namespace containing all symbols from the Eigen library.
namespace	Eigen::internal

Macros
#define	EIGEN_WORLD_VERSION   3
#define	EIGEN_MAJOR_VERSION   4
#define	EIGEN_MINOR_VERSION   0
#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
	Allows to disable some optimizations which might affect the accuracy of the result. More...
#define	EIGEN_STACK_ALLOCATION_LIMIT   131072
#define	EIGEN_COMP_GNUC   0
#define	EIGEN_COMP_CLANG   0
#define	EIGEN_COMP_CASTXML   0
#define	EIGEN_COMP_LLVM   0
#define	EIGEN_COMP_ICC   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_ARM   0
#define	EIGEN_COMP_EMSCRIPTEN   0
#define	EIGEN_COMP_GNUC_STRICT   0
#define	EIGEN_GNUC_AT_LEAST(x, y)   0
#define	EIGEN_GNUC_AT_MOST(x, y)   0
#define	EIGEN_GNUC_AT(x, y)   0
#define	EIGEN_GCC3_OR_OLDER   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_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_SAFE_TO_USE_STANDARD_ASSERT_MACRO   1
#define	EIGEN_HAS_BUILTIN(x)   0
#define	__has_feature(x)   0
#define	EIGEN_HAS_STATIC_ARRAY_TEMPLATE   1
#define	EIGEN_CPLUSPLUS   __cplusplus
#define	EIGEN_COMP_CXXVER   03
#define	EIGEN_HAS_CXX14_VARIABLE_TEMPLATES   0
#define	EIGEN_HAS_CXX11   0
#define	EIGEN_HAS_CXX14   0
#define	EIGEN_HAS_RVALUE_REFERENCES   0
#define	EIGEN_HAS_C99_MATH   0
#define	EIGEN_HAS_STD_RESULT_OF   0
#define	EIGEN_HAS_STD_HASH   0
#define	EIGEN_HAS_STD_INVOKE_RESULT   0
#define	EIGEN_HAS_ALIGNAS   0
#define	EIGEN_HAS_TYPE_TRAITS   0
#define	EIGEN_HAS_VARIADIC_TEMPLATES   0
#define	EIGEN_HAS_CONSTEXPR   0
#define	EIGEN_CONSTEXPR
#define	EIGEN_HAS_CXX11_MATH   0
#define	EIGEN_HAS_CXX11_CONTAINERS   0
#define	EIGEN_HAS_CXX11_NOEXCEPT   0
#define	EIGEN_HAS_CXX11_ATOMIC   0
#define	EIGEN_HAS_CXX11_OVERRIDE_FINAL   0
#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_plain_assert(x)   assert(x)
#define	eigen_assert(x)   eigen_plain_assert(x)
#define	eigen_internal_assert(x)
#define	EIGEN_ONLY_USED_FOR_DEBUG(x)
#define	EIGEN_DEPRECATED
#define	EIGEN_UNUSED
#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)
#define	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
#define	EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)
#define	EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
	Just a side note. More...
#define	EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
#define	EIGEN_PLAIN_ENUM_MIN(a, b)   (((int)a <= (int)b) ? (int)a : (int)b)
#define	EIGEN_PLAIN_ENUM_MAX(a, b)   (((int)a >= (int)b) ? (int)a : (int)b)
#define	EIGEN_SIZE_MIN_PREFER_DYNAMIC(a, b)
#define	EIGEN_SIZE_MIN_PREFER_FIXED(a, b)
#define	EIGEN_SIZE_MAX(a, b)
#define	EIGEN_LOGICAL_XOR(a, b)   (((a) || (b)) && !((a) && (b)))
#define	EIGEN_IMPLIES(a, b)   (!(a) || (b))
#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)    (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA,TYPEB,EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_,OPNAME),_op)<TYPEA,TYPEB> > >::value)
#define	EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR, SCALAR, OPNAME)
#define	EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR, EXPR, 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
#define	EIGEN_NOEXCEPT_IF(x)
#define	EIGEN_NO_THROW   throw()
#define	EIGEN_EXCEPTION_SPEC(X)   throw(X)
#define	EIGEN_OVERRIDE
#define	EIGEN_FINAL
#define	EIGEN_UNROLL_LOOP

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

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_ARM64

#define EIGEN_ARCH_ARM64   0

EIGEN_ARCH_ARM_OR_ARM64

#define EIGEN_ARCH_ARM_OR_ARM64   0

EIGEN_ARCH_ARMV8

#define EIGEN_ARCH_ARMV8   0

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_MIPS

#define EIGEN_ARCH_MIPS   0

EIGEN_ARCH_PPC

#define EIGEN_ARCH_PPC   0

EIGEN_ARCH_SPARC

#define EIGEN_ARCH_SPARC   0

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_COMMA

#define EIGEN_COMMA   ,

EIGEN_COMP_ARM

#define EIGEN_COMP_ARM   0

EIGEN_COMP_CASTXML

#define EIGEN_COMP_CASTXML   0

EIGEN_COMP_CLANG

#define EIGEN_COMP_CLANG   0

EIGEN_COMP_CXXVER

#define EIGEN_COMP_CXXVER   03

EIGEN_COMP_EMSCRIPTEN

#define EIGEN_COMP_EMSCRIPTEN   0

EIGEN_COMP_GNUC

#define EIGEN_COMP_GNUC   0

EIGEN_COMP_GNUC_STRICT

#define EIGEN_COMP_GNUC_STRICT   0

EIGEN_COMP_IBM

#define EIGEN_COMP_IBM   0

EIGEN_COMP_ICC

#define EIGEN_COMP_ICC   0

EIGEN_COMP_LLVM

#define EIGEN_COMP_LLVM   0

EIGEN_COMP_MINGW

#define EIGEN_COMP_MINGW   0

EIGEN_COMP_MSVC

#define EIGEN_COMP_MSVC   0

EIGEN_COMP_MSVC_LANG

#define EIGEN_COMP_MSVC_LANG   0

EIGEN_COMP_MSVC_STRICT

#define EIGEN_COMP_MSVC_STRICT   0

EIGEN_COMP_NVCC

#define EIGEN_COMP_NVCC   0

EIGEN_COMP_PGI

#define EIGEN_COMP_PGI   0

EIGEN_COMP_SUNCC

#define EIGEN_COMP_SUNCC   0

EIGEN_CONST_CONDITIONAL

#define EIGEN_CONST_CONDITIONAL

(

cond

)

cond

EIGEN_CONSTEXPR

#define EIGEN_CONSTEXPR

EIGEN_CPLUSPLUS

#define EIGEN_CPLUSPLUS   __cplusplus

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_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:

    Derived() {}; \
    /* ~Derived() {}; */

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_DEPRECATED

#define EIGEN_DEPRECATED

EIGEN_DEVICE_FUNC

#define EIGEN_DEVICE_FUNC

EIGEN_DONT_INLINE

#define EIGEN_DONT_INLINE

EIGEN_EMPTY

#define EIGEN_EMPTY

EIGEN_EXCEPTION_SPEC

#define EIGEN_EXCEPTION_SPEC

(

X

)

throw(X)

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

EIGEN_GCC3_OR_OLDER

#define EIGEN_GCC3_OR_OLDER   0

EIGEN_GENERIC_PUBLIC_INTERFACE

#define EIGEN_GENERIC_PUBLIC_INTERFACE

(

Derived

)

Value:

  typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, T were corresponding to RealScalar. */ \
  typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \
  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_AT

#define EIGEN_GNUC_AT	(		x,
			y
	)		0

EIGEN_GNUC_AT_LEAST

#define EIGEN_GNUC_AT_LEAST	(		x,
			y
	)		0

EIGEN_GNUC_AT_MOST

#define EIGEN_GNUC_AT_MOST	(		x,
			y
	)		0

EIGEN_HAS_ALIGNAS

#define EIGEN_HAS_ALIGNAS   0

EIGEN_HAS_BUILTIN

#define EIGEN_HAS_BUILTIN

(

x

)

0

EIGEN_HAS_BUILTIN_INT128

#define EIGEN_HAS_BUILTIN_INT128   0

EIGEN_HAS_C99_MATH

#define EIGEN_HAS_C99_MATH   0

EIGEN_HAS_CONSTEXPR

#define EIGEN_HAS_CONSTEXPR   0

EIGEN_HAS_CXX11

#define EIGEN_HAS_CXX11   0

EIGEN_HAS_CXX11_ATOMIC

#define EIGEN_HAS_CXX11_ATOMIC   0

EIGEN_HAS_CXX11_CONTAINERS

#define EIGEN_HAS_CXX11_CONTAINERS   0

EIGEN_HAS_CXX11_MATH

#define EIGEN_HAS_CXX11_MATH   0

EIGEN_HAS_CXX11_NOEXCEPT

#define EIGEN_HAS_CXX11_NOEXCEPT   0

EIGEN_HAS_CXX11_OVERRIDE_FINAL

#define EIGEN_HAS_CXX11_OVERRIDE_FINAL   0

EIGEN_HAS_CXX14

#define EIGEN_HAS_CXX14   0

EIGEN_HAS_CXX14_VARIABLE_TEMPLATES

#define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES   0

EIGEN_HAS_CXX17_OVERALIGN

#define EIGEN_HAS_CXX17_OVERALIGN   0

EIGEN_HAS_RVALUE_REFERENCES

#define EIGEN_HAS_RVALUE_REFERENCES   0

EIGEN_HAS_STATIC_ARRAY_TEMPLATE

#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE   1

EIGEN_HAS_STD_HASH

#define EIGEN_HAS_STD_HASH   0

EIGEN_HAS_STD_INVOKE_RESULT

#define EIGEN_HAS_STD_INVOKE_RESULT   0

EIGEN_HAS_STD_RESULT_OF

#define EIGEN_HAS_STD_RESULT_OF   0

EIGEN_HAS_TYPE_TRAITS

#define EIGEN_HAS_TYPE_TRAITS   0

EIGEN_HAS_VARIADIC_TEMPLATES

#define EIGEN_HAS_VARIADIC_TEMPLATES   0

EIGEN_HIP_LAUNCH_BOUNDS_1024

#define EIGEN_HIP_LAUNCH_BOUNDS_1024

EIGEN_IMPLIES

#define EIGEN_IMPLIES	(		a,
			b
	)		(!(a) || (b))

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_internal_assert

#define eigen_internal_assert

(

x

)

EIGEN_LOGICAL_XOR

#define EIGEN_LOGICAL_XOR	(		a,
			b
	)		(((a) || (b)) && !((a) && (b)))

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
	)

Value:

  template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend \
  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(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 \
  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(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   0

EIGEN_NO_THROW

#define EIGEN_NO_THROW   throw()

EIGEN_NOEXCEPT

#define EIGEN_NOEXCEPT

EIGEN_NOEXCEPT_IF

#define EIGEN_NOEXCEPT_IF

(

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_BSD

#define EIGEN_OS_BSD   0

EIGEN_OS_CYGWIN

#define EIGEN_OS_CYGWIN   0

EIGEN_OS_GNULINUX

#define EIGEN_OS_GNULINUX   0

EIGEN_OS_LINUX

#define EIGEN_OS_LINUX   0

EIGEN_OS_MAC

#define EIGEN_OS_MAC   0

EIGEN_OS_QNX

#define EIGEN_OS_QNX   0

EIGEN_OS_SOLARIS

#define EIGEN_OS_SOLARIS   0

EIGEN_OS_SUN

#define EIGEN_OS_SUN   0

EIGEN_OS_UNIX

#define EIGEN_OS_UNIX   0

EIGEN_OS_WIN

#define EIGEN_OS_WIN   0

EIGEN_OS_WIN64

#define EIGEN_OS_WIN64   0

EIGEN_OS_WIN_STRICT

#define EIGEN_OS_WIN_STRICT   0

EIGEN_OS_WINCE

#define EIGEN_OS_WINCE   0

EIGEN_OVERRIDE

#define EIGEN_OVERRIDE

EIGEN_PERMISSIVE_EXPR

#define EIGEN_PERMISSIVE_EXPR

eigen_plain_assert

#define eigen_plain_assert

(

x

)

assert(x)

EIGEN_PLAIN_ENUM_MAX

#define EIGEN_PLAIN_ENUM_MAX	(		a,
			b
	)		(((int)a >= (int)b) ? (int)a : (int)b)

EIGEN_PLAIN_ENUM_MIN

#define EIGEN_PLAIN_ENUM_MIN	(		a,
			b
	)		(((int)a <= (int)b) ? (int)a : (int)b)

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_SAFE_TO_USE_STANDARD_ASSERT_MACRO

#define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO   1

EIGEN_SCALAR_BINARY_SUPPORTED

#define EIGEN_SCALAR_BINARY_SUPPORTED	(		OPNAME,
			TYPEA,
			TYPEB
	)		(Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA,TYPEB,EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_,OPNAME),_op)<TYPEA,TYPEB> > >::value)

EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE

#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE	(		SCALAR,
			EXPR,
			OPNAME
	)

Value:

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

EIGEN_SIZE_MAX

#define EIGEN_SIZE_MAX	(		a,
			b
	)

Value:

                           (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
                           : ((int)a >= (int)b) ? (int)a : (int)b)

EIGEN_SIZE_MIN_PREFER_DYNAMIC

#define EIGEN_SIZE_MIN_PREFER_DYNAMIC	(		a,
			b
	)

Value:

                           (((int)a == 0 || (int)b == 0) ? 0 \
                           : ((int)a == 1 || (int)b == 1) ? 1 \
                           : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
                           : ((int)a <= (int)b) ? (int)a : (int)b)

EIGEN_SIZE_MIN_PREFER_FIXED

#define EIGEN_SIZE_MIN_PREFER_FIXED	(		a,
			b
	)

Value:

                           (((int)a == 0 || (int)b == 0) ? 0 \
                           : ((int)a == 1 || (int)b == 1) ? 1 \
                           : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
                           : ((int)a == Dynamic) ? (int)b \
                           : ((int)b == Dynamic) ? (int)a \
                           : ((int)a <= (int)b) ? (int)a : (int)b)

EIGEN_STACK_ALLOCATION_LIMIT

#define EIGEN_STACK_ALLOCATION_LIMIT   131072

EIGEN_STRONG_INLINE

#define EIGEN_STRONG_INLINE   inline

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_WORLD_VERSION

#define EIGEN_WORLD_VERSION   3