Macros.h
Go to the documentation of this file.
00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
00005 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
00006 //
00007 // Eigen is free software; you can redistribute it and/or
00008 // modify it under the terms of the GNU Lesser General Public
00009 // License as published by the Free Software Foundation; either
00010 // version 3 of the License, or (at your option) any later version.
00011 //
00012 // Alternatively, you can redistribute it and/or
00013 // modify it under the terms of the GNU General Public License as
00014 // published by the Free Software Foundation; either version 2 of
00015 // the License, or (at your option) any later version.
00016 //
00017 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
00018 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00019 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
00020 // GNU General Public License for more details.
00021 //
00022 // You should have received a copy of the GNU Lesser General Public
00023 // License and a copy of the GNU General Public License along with
00024 // Eigen. If not, see <http://www.gnu.org/licenses/>.
00025 
00026 #ifndef EIGEN_MACROS_H
00027 #define EIGEN_MACROS_H
00028 
00029 #define EIGEN_WORLD_VERSION 3
00030 #define EIGEN_MAJOR_VERSION 0
00031 #define EIGEN_MINOR_VERSION 2
00032 
00033 #define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
00034                                       (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
00035                                                                  EIGEN_MINOR_VERSION>=z))))
00036 #ifdef __GNUC__
00037   #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__==x && __GNUC_MINOR__>=y) || __GNUC__>x)
00038 #else
00039   #define EIGEN_GNUC_AT_LEAST(x,y) 0
00040 #endif
00041  
00042 #ifdef __GNUC__
00043   #define EIGEN_GNUC_AT_MOST(x,y) ((__GNUC__==x && __GNUC_MINOR__<=y) || __GNUC__<x)
00044 #else
00045   #define EIGEN_GNUC_AT_MOST(x,y) 0
00046 #endif
00047 
00048 #if EIGEN_GNUC_AT_MOST(4,3)
00049   // see bug 89
00050   #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 0
00051 #else
00052   #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 1
00053 #endif
00054 
00055 #if defined(__GNUC__) && (__GNUC__ <= 3)
00056 #define EIGEN_GCC3_OR_OLDER 1
00057 #else
00058 #define EIGEN_GCC3_OR_OLDER 0
00059 #endif
00060 
00061 // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable
00062 // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always
00063 // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in
00064 // certain common platform (compiler+architecture combinations) to avoid these problems.
00065 // Only static alignment is really problematic (relies on nonstandard compiler extensions that don't
00066 // work everywhere, for example don't work on GCC/ARM), try to keep heap alignment even
00067 // when we have to disable static alignment.
00068 #if defined(__GNUC__) && !(defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) || defined(__ppc__) || defined(__ia64__))
00069 #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
00070 #else
00071 #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0
00072 #endif
00073 
00074 // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX
00075 #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT \
00076  && !EIGEN_GCC3_OR_OLDER \
00077  && !defined(__SUNPRO_CC) \
00078  && !defined(__QNXNTO__)
00079   #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 1
00080 #else
00081   #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 0
00082 #endif
00083 
00084 #ifdef EIGEN_DONT_ALIGN
00085   #ifndef EIGEN_DONT_ALIGN_STATICALLY
00086     #define EIGEN_DONT_ALIGN_STATICALLY
00087   #endif
00088   #define EIGEN_ALIGN 0
00089 #else
00090   #define EIGEN_ALIGN 1
00091 #endif
00092 
00093 // EIGEN_ALIGN_STATICALLY is the true test whether we want to align arrays on the stack or not. It takes into account both the user choice to explicitly disable
00094 // alignment (EIGEN_DONT_ALIGN_STATICALLY) and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT). Henceforth, only EIGEN_ALIGN_STATICALLY should be used.
00095 #if EIGEN_ARCH_WANTS_STACK_ALIGNMENT && !defined(EIGEN_DONT_ALIGN_STATICALLY)
00096   #define EIGEN_ALIGN_STATICALLY 1
00097 #else
00098   #define EIGEN_ALIGN_STATICALLY 0
00099   #ifndef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
00100     #define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
00101   #endif
00102 #endif
00103 
00104 #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
00105 #define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION RowMajor
00106 #else
00107 #define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ColMajor
00108 #endif
00109 
00110 #ifndef EIGEN_DEFAULT_DENSE_INDEX_TYPE
00111 #define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t
00112 #endif
00113 
00119 #ifndef EIGEN_FAST_MATH
00120 #define EIGEN_FAST_MATH 1
00121 #endif
00122 
00123 #define EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;
00124 
00125 // concatenate two tokens
00126 #define EIGEN_CAT2(a,b) a ## b
00127 #define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
00128 
00129 // convert a token to a string
00130 #define EIGEN_MAKESTRING2(a) #a
00131 #define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
00132 
00133 // EIGEN_ALWAYS_INLINE_ATTRIB should be use in the declaration of function
00134 // which should be inlined even in debug mode.
00135 // FIXME with the always_inline attribute,
00136 // gcc 3.4.x reports the following compilation error:
00137 //   Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const'
00138 //    : function body not available
00139 #if EIGEN_GNUC_AT_LEAST(4,0)
00140 #define EIGEN_ALWAYS_INLINE_ATTRIB __attribute__((always_inline))
00141 #else
00142 #define EIGEN_ALWAYS_INLINE_ATTRIB
00143 #endif
00144 
00145 #if EIGEN_GNUC_AT_LEAST(4,1) && !defined(__clang__) && !defined(__INTEL_COMPILER)
00146 #define EIGEN_FLATTEN_ATTRIB __attribute__((flatten))
00147 #else
00148 #define EIGEN_FLATTEN_ATTRIB
00149 #endif
00150 
00151 // EIGEN_FORCE_INLINE means "inline as much as possible"
00152 #if (defined _MSC_VER) || (defined __INTEL_COMPILER)
00153 #define EIGEN_STRONG_INLINE __forceinline
00154 #else
00155 #define EIGEN_STRONG_INLINE inline
00156 #endif
00157 
00158 #if (defined __GNUC__)
00159 #define EIGEN_DONT_INLINE __attribute__((noinline))
00160 #elif (defined _MSC_VER)
00161 #define EIGEN_DONT_INLINE __declspec(noinline)
00162 #else
00163 #define EIGEN_DONT_INLINE
00164 #endif
00165 
00166 // this macro allows to get rid of linking errors about multiply defined functions.
00167 //  - static is not very good because it prevents definitions from different object files to be merged.
00168 //           So static causes the resulting linked executable to be bloated with multiple copies of the same function.
00169 //  - inline is not perfect either as it unwantedly hints the compiler toward inlining the function.
00170 #define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
00171 #define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS inline
00172 
00173 #ifdef NDEBUG
00174 # ifndef EIGEN_NO_DEBUG
00175 #  define EIGEN_NO_DEBUG
00176 # endif
00177 #endif
00178 
00179 // eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89
00180 #ifdef EIGEN_NO_DEBUG
00181   #define eigen_plain_assert(x)
00182 #else
00183   #if EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO
00184     namespace Eigen {
00185     namespace internal {
00186     inline bool copy_bool(bool b) { return b; }
00187     }
00188     }
00189     #define eigen_plain_assert(x) assert(x)
00190   #else
00191     // work around bug 89
00192     #include <cstdlib>   // for abort
00193     #include <iostream>  // for std::cerr
00194 
00195     namespace Eigen {
00196     namespace internal {
00197     // trivial function copying a bool. Must be EIGEN_DONT_INLINE, so we implement it after including Eigen headers.
00198     // see bug 89.
00199     namespace {
00200     EIGEN_DONT_INLINE bool copy_bool(bool b) { return b; }
00201     }
00202     inline void assert_fail(const char *condition, const char *function, const char *file, int line)
00203     {
00204       std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
00205       abort();
00206     }
00207     }
00208     }
00209     #define eigen_plain_assert(x) \
00210       do { \
00211         if(!Eigen::internal::copy_bool(x)) \
00212           Eigen::internal::assert_fail(EIGEN_MAKESTRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__); \
00213       } while(false)
00214   #endif
00215 #endif
00216 
00217 // eigen_assert can be overridden
00218 #ifndef eigen_assert
00219 #define eigen_assert(x) eigen_plain_assert(x)
00220 #endif
00221 
00222 #ifdef EIGEN_INTERNAL_DEBUGGING
00223 #define eigen_internal_assert(x) eigen_assert(x)
00224 #else
00225 #define eigen_internal_assert(x)
00226 #endif
00227 
00228 #ifdef EIGEN_NO_DEBUG
00229 #define EIGEN_ONLY_USED_FOR_DEBUG(x) (void)x
00230 #else
00231 #define EIGEN_ONLY_USED_FOR_DEBUG(x)
00232 #endif
00233 
00234 #if (defined __GNUC__)
00235 #define EIGEN_DEPRECATED __attribute__((deprecated))
00236 #elif (defined _MSC_VER)
00237 #define EIGEN_DEPRECATED __declspec(deprecated)
00238 #else
00239 #define EIGEN_DEPRECATED
00240 #endif
00241 
00242 #if (defined __GNUC__)
00243 #define EIGEN_UNUSED __attribute__((unused))
00244 #else
00245 #define EIGEN_UNUSED
00246 #endif
00247 
00248 // Suppresses 'unused variable' warnings.
00249 #define EIGEN_UNUSED_VARIABLE(var) (void)var;
00250 
00251 #if (defined __GNUC__)
00252 #define EIGEN_ASM_COMMENT(X)  asm("#"X)
00253 #else
00254 #define EIGEN_ASM_COMMENT(X)
00255 #endif
00256 
00257 /* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements.
00258  * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled,
00259  * so that vectorization doesn't affect binary compatibility.
00260  *
00261  * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link
00262  * vectorized and non-vectorized code.
00263  */
00264 #if (defined __GNUC__) || (defined __PGI) || (defined __IBMCPP__)
00265   #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
00266 #elif (defined _MSC_VER)
00267   #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n))
00268 #elif (defined __SUNPRO_CC)
00269   // FIXME not sure about this one:
00270   #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
00271 #else
00272   #error Please tell me what is the equivalent of __attribute__((aligned(n))) for your compiler
00273 #endif
00274 
00275 #define EIGEN_ALIGN16 EIGEN_ALIGN_TO_BOUNDARY(16)
00276 
00277 #if EIGEN_ALIGN_STATICALLY
00278 #define EIGEN_USER_ALIGN_TO_BOUNDARY(n) EIGEN_ALIGN_TO_BOUNDARY(n)
00279 #define EIGEN_USER_ALIGN16 EIGEN_ALIGN16
00280 #else
00281 #define EIGEN_USER_ALIGN_TO_BOUNDARY(n)
00282 #define EIGEN_USER_ALIGN16
00283 #endif
00284 
00285 #ifdef EIGEN_DONT_USE_RESTRICT_KEYWORD
00286   #define EIGEN_RESTRICT
00287 #endif
00288 #ifndef EIGEN_RESTRICT
00289   #define EIGEN_RESTRICT __restrict
00290 #endif
00291 
00292 #ifndef EIGEN_STACK_ALLOCATION_LIMIT
00293 #define EIGEN_STACK_ALLOCATION_LIMIT 20000
00294 #endif
00295 
00296 #ifndef EIGEN_DEFAULT_IO_FORMAT
00297 #ifdef EIGEN_MAKING_DOCS
00298 // format used in Eigen's documentation
00299 // needed to define it here as escaping characters in CMake add_definition's argument seems very problematic.
00300 #define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat(3, 0, " ", "\n", "", "")
00301 #else
00302 #define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()
00303 #endif
00304 #endif
00305 
00306 // just an empty macro !
00307 #define EIGEN_EMPTY
00308 
00309 #if defined(_MSC_VER) && (!defined(__INTEL_COMPILER))
00310 #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
00311   using Base::operator =;
00312 #else
00313 #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
00314   using Base::operator =; \
00315   EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) \
00316   { \
00317     Base::operator=(other); \
00318     return *this; \
00319   }
00320 #endif
00321 
00322 #define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
00323   EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)
00324 
00333 #define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
00334   typedef typename Eigen::internal::traits<Derived>::Scalar Scalar;  \
00335   typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;  \
00336   typedef typename Base::CoeffReturnType CoeffReturnType;  \
00337   typedef typename Eigen::internal::nested<Derived>::type Nested; \
00338   typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
00339   typedef typename Eigen::internal::traits<Derived>::Index Index; \
00340   enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
00341         ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
00342         Flags = Eigen::internal::traits<Derived>::Flags, \
00343         CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \
00344         SizeAtCompileTime = Base::SizeAtCompileTime, \
00345         MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
00346         IsVectorAtCompileTime = Base::IsVectorAtCompileTime };
00347 
00348 
00349 #define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
00350   typedef typename Eigen::internal::traits<Derived>::Scalar Scalar;  \
00351   typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;  \
00352   typedef typename Base::PacketScalar PacketScalar; \
00353   typedef typename Base::CoeffReturnType CoeffReturnType;  \
00354   typedef typename Eigen::internal::nested<Derived>::type Nested; \
00355   typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
00356   typedef typename Eigen::internal::traits<Derived>::Index Index; \
00357   enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
00358         ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
00359         MaxRowsAtCompileTime = Eigen::internal::traits<Derived>::MaxRowsAtCompileTime, \
00360         MaxColsAtCompileTime = Eigen::internal::traits<Derived>::MaxColsAtCompileTime, \
00361         Flags = Eigen::internal::traits<Derived>::Flags, \
00362         CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \
00363         SizeAtCompileTime = Base::SizeAtCompileTime, \
00364         MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
00365         IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
00366   using Base::derived; \
00367   using Base::const_cast_derived;
00368 
00369 
00370 #define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
00371 #define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
00372 
00373 // EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
00374 // followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
00375 // finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
00376 #define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \
00377                            : ((int)a == 1 || (int)b == 1) ? 1 \
00378                            : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
00379                            : ((int)a <= (int)b) ? (int)a : (int)b)
00380 
00381 // EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values
00382 // now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is
00383 // (between 0 and 3), it is not more than 3.
00384 #define EIGEN_SIZE_MIN_PREFER_FIXED(a,b)  (((int)a == 0 || (int)b == 0) ? 0 \
00385                            : ((int)a == 1 || (int)b == 1) ? 1 \
00386                            : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
00387                            : ((int)a == Dynamic) ? (int)b \
00388                            : ((int)b == Dynamic) ? (int)a \
00389                            : ((int)a <= (int)b) ? (int)a : (int)b)
00390 
00391 // see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here.
00392 #define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
00393                            : ((int)a >= (int)b) ? (int)a : (int)b)
00394 
00395 #define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
00396 
00397 #define EIGEN_IMPLIES(a,b) (!(a) || (b))
00398 
00399 #define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \
00400   template<typename OtherDerived> \
00401   EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \
00402   (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
00403   { \
00404     return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \
00405   }
00406 
00407 // the expression type of a cwise product
00408 #define EIGEN_CWISE_PRODUCT_RETURN_TYPE(LHS,RHS) \
00409     CwiseBinaryOp< \
00410       internal::scalar_product_op< \
00411           typename internal::traits<LHS>::Scalar, \
00412           typename internal::traits<RHS>::Scalar \
00413       >, \
00414       const LHS, \
00415       const RHS \
00416     >
00417 
00418 #endif // EIGEN_MACROS_H


libicr
Author(s): Robert Krug
autogenerated on Mon Jan 6 2014 11:32:59