Another set of UI messages fixes and tweaks! No functional changes.
[blender.git] / extern / Eigen3 / Eigen / src / Core / util / Macros.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
6 //
7 // Eigen is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Lesser General Public
9 // License as published by the Free Software Foundation; either
10 // version 3 of the License, or (at your option) any later version.
11 //
12 // Alternatively, you can redistribute it and/or
13 // modify it under the terms of the GNU General Public License as
14 // published by the Free Software Foundation; either version 2 of
15 // the License, or (at your option) any later version.
16 //
17 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License and a copy of the GNU General Public License along with
24 // Eigen. If not, see <http://www.gnu.org/licenses/>.
25
26 #ifndef EIGEN_MACROS_H
27 #define EIGEN_MACROS_H
28
29 #define EIGEN_WORLD_VERSION 3
30 #define EIGEN_MAJOR_VERSION 0
31 #define EIGEN_MINOR_VERSION 2
32
33 #define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
34                                       (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
35                                                                  EIGEN_MINOR_VERSION>=z))))
36 #ifdef __GNUC__
37   #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__==x && __GNUC_MINOR__>=y) || __GNUC__>x)
38 #else
39   #define EIGEN_GNUC_AT_LEAST(x,y) 0
40 #endif
41  
42 #ifdef __GNUC__
43   #define EIGEN_GNUC_AT_MOST(x,y) ((__GNUC__==x && __GNUC_MINOR__<=y) || __GNUC__<x)
44 #else
45   #define EIGEN_GNUC_AT_MOST(x,y) 0
46 #endif
47
48 #if EIGEN_GNUC_AT_MOST(4,3)
49   // see bug 89
50   #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 0
51 #else
52   #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 1
53 #endif
54
55 #if defined(__GNUC__) && (__GNUC__ <= 3)
56 #define EIGEN_GCC3_OR_OLDER 1
57 #else
58 #define EIGEN_GCC3_OR_OLDER 0
59 #endif
60
61 // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable
62 // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always
63 // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in
64 // certain common platform (compiler+architecture combinations) to avoid these problems.
65 // Only static alignment is really problematic (relies on nonstandard compiler extensions that don't
66 // work everywhere, for example don't work on GCC/ARM), try to keep heap alignment even
67 // when we have to disable static alignment.
68 #if defined(__GNUC__) && !(defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) || defined(__ppc__) || defined(__ia64__))
69 #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
70 #else
71 #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0
72 #endif
73
74 // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX
75 #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT \
76  && !EIGEN_GCC3_OR_OLDER \
77  && !defined(__SUNPRO_CC) \
78  && !defined(__QNXNTO__)
79   #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 1
80 #else
81   #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 0
82 #endif
83
84 #ifdef EIGEN_DONT_ALIGN
85   #ifndef EIGEN_DONT_ALIGN_STATICALLY
86     #define EIGEN_DONT_ALIGN_STATICALLY
87   #endif
88   #define EIGEN_ALIGN 0
89 #else
90   #define EIGEN_ALIGN 1
91 #endif
92
93 // 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
94 // alignment (EIGEN_DONT_ALIGN_STATICALLY) and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT). Henceforth, only EIGEN_ALIGN_STATICALLY should be used.
95 #if EIGEN_ARCH_WANTS_STACK_ALIGNMENT && !defined(EIGEN_DONT_ALIGN_STATICALLY)
96   #define EIGEN_ALIGN_STATICALLY 1
97 #else
98   #define EIGEN_ALIGN_STATICALLY 0
99   #ifndef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
100     #define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
101   #endif
102 #endif
103
104 #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
105 #define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION RowMajor
106 #else
107 #define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ColMajor
108 #endif
109
110 #ifndef EIGEN_DEFAULT_DENSE_INDEX_TYPE
111 #define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t
112 #endif
113
114 /** Allows to disable some optimizations which might affect the accuracy of the result.
115   * Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them.
116   * They currently include:
117   *   - single precision Cwise::sin() and Cwise::cos() when SSE vectorization is enabled.
118   */
119 #ifndef EIGEN_FAST_MATH
120 #define EIGEN_FAST_MATH 1
121 #endif
122
123 #define EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;
124
125 // concatenate two tokens
126 #define EIGEN_CAT2(a,b) a ## b
127 #define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
128
129 // convert a token to a string
130 #define EIGEN_MAKESTRING2(a) #a
131 #define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
132
133 // EIGEN_ALWAYS_INLINE_ATTRIB should be use in the declaration of function
134 // which should be inlined even in debug mode.
135 // FIXME with the always_inline attribute,
136 // gcc 3.4.x reports the following compilation error:
137 //   Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const'
138 //    : function body not available
139 #if EIGEN_GNUC_AT_LEAST(4,0)
140 #define EIGEN_ALWAYS_INLINE_ATTRIB __attribute__((always_inline))
141 #else
142 #define EIGEN_ALWAYS_INLINE_ATTRIB
143 #endif
144
145 #if EIGEN_GNUC_AT_LEAST(4,1) && !defined(__clang__) && !defined(__INTEL_COMPILER)
146 #define EIGEN_FLATTEN_ATTRIB __attribute__((flatten))
147 #else
148 #define EIGEN_FLATTEN_ATTRIB
149 #endif
150
151 // EIGEN_FORCE_INLINE means "inline as much as possible"
152 #if (defined _MSC_VER) || (defined __INTEL_COMPILER)
153 #define EIGEN_STRONG_INLINE __forceinline
154 #else
155 #define EIGEN_STRONG_INLINE inline
156 #endif
157
158 #if (defined __GNUC__)
159 #define EIGEN_DONT_INLINE __attribute__((noinline))
160 #elif (defined _MSC_VER)
161 #define EIGEN_DONT_INLINE __declspec(noinline)
162 #else
163 #define EIGEN_DONT_INLINE
164 #endif
165
166 // this macro allows to get rid of linking errors about multiply defined functions.
167 //  - static is not very good because it prevents definitions from different object files to be merged.
168 //           So static causes the resulting linked executable to be bloated with multiple copies of the same function.
169 //  - inline is not perfect either as it unwantedly hints the compiler toward inlining the function.
170 #define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
171 #define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS inline
172
173 #ifdef NDEBUG
174 # ifndef EIGEN_NO_DEBUG
175 #  define EIGEN_NO_DEBUG
176 # endif
177 #endif
178
179 // eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89
180 #ifdef EIGEN_NO_DEBUG
181   #define eigen_plain_assert(x)
182 #else
183   #if EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO
184     namespace Eigen {
185     namespace internal {
186     inline bool copy_bool(bool b) { return b; }
187     }
188     }
189     #define eigen_plain_assert(x) assert(x)
190   #else
191     // work around bug 89
192     #include <cstdlib>   // for abort
193     #include <iostream>  // for std::cerr
194
195     namespace Eigen {
196     namespace internal {
197     // trivial function copying a bool. Must be EIGEN_DONT_INLINE, so we implement it after including Eigen headers.
198     // see bug 89.
199     namespace {
200     EIGEN_DONT_INLINE bool copy_bool(bool b) { return b; }
201     }
202     inline void assert_fail(const char *condition, const char *function, const char *file, int line)
203     {
204       std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
205       abort();
206     }
207     }
208     }
209     #define eigen_plain_assert(x) \
210       do { \
211         if(!Eigen::internal::copy_bool(x)) \
212           Eigen::internal::assert_fail(EIGEN_MAKESTRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__); \
213       } while(false)
214   #endif
215 #endif
216
217 // eigen_assert can be overridden
218 #ifndef eigen_assert
219 #define eigen_assert(x) eigen_plain_assert(x)
220 #endif
221
222 #ifdef EIGEN_INTERNAL_DEBUGGING
223 #define eigen_internal_assert(x) eigen_assert(x)
224 #else
225 #define eigen_internal_assert(x)
226 #endif
227
228 #ifdef EIGEN_NO_DEBUG
229 #define EIGEN_ONLY_USED_FOR_DEBUG(x) (void)x
230 #else
231 #define EIGEN_ONLY_USED_FOR_DEBUG(x)
232 #endif
233
234 #if (defined __GNUC__)
235 #define EIGEN_DEPRECATED __attribute__((deprecated))
236 #elif (defined _MSC_VER)
237 #define EIGEN_DEPRECATED __declspec(deprecated)
238 #else
239 #define EIGEN_DEPRECATED
240 #endif
241
242 #if (defined __GNUC__)
243 #define EIGEN_UNUSED __attribute__((unused))
244 #else
245 #define EIGEN_UNUSED
246 #endif
247
248 // Suppresses 'unused variable' warnings.
249 #define EIGEN_UNUSED_VARIABLE(var) (void)var;
250
251 #if (defined __GNUC__)
252 #define EIGEN_ASM_COMMENT(X)  asm("#"X)
253 #else
254 #define EIGEN_ASM_COMMENT(X)
255 #endif
256
257 /* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements.
258  * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled,
259  * so that vectorization doesn't affect binary compatibility.
260  *
261  * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link
262  * vectorized and non-vectorized code.
263  */
264 #if (defined __GNUC__) || (defined __PGI) || (defined __IBMCPP__)
265   #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
266 #elif (defined _MSC_VER)
267   #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n))
268 #elif (defined __SUNPRO_CC)
269   // FIXME not sure about this one:
270   #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
271 #else
272   #error Please tell me what is the equivalent of __attribute__((aligned(n))) for your compiler
273 #endif
274
275 #define EIGEN_ALIGN16 EIGEN_ALIGN_TO_BOUNDARY(16)
276
277 #if EIGEN_ALIGN_STATICALLY
278 #define EIGEN_USER_ALIGN_TO_BOUNDARY(n) EIGEN_ALIGN_TO_BOUNDARY(n)
279 #define EIGEN_USER_ALIGN16 EIGEN_ALIGN16
280 #else
281 #define EIGEN_USER_ALIGN_TO_BOUNDARY(n)
282 #define EIGEN_USER_ALIGN16
283 #endif
284
285 #ifdef EIGEN_DONT_USE_RESTRICT_KEYWORD
286   #define EIGEN_RESTRICT
287 #endif
288 #ifndef EIGEN_RESTRICT
289   #define EIGEN_RESTRICT __restrict
290 #endif
291
292 #ifndef EIGEN_STACK_ALLOCATION_LIMIT
293 #define EIGEN_STACK_ALLOCATION_LIMIT 20000
294 #endif
295
296 #ifndef EIGEN_DEFAULT_IO_FORMAT
297 #ifdef EIGEN_MAKING_DOCS
298 // format used in Eigen's documentation
299 // needed to define it here as escaping characters in CMake add_definition's argument seems very problematic.
300 #define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat(3, 0, " ", "\n", "", "")
301 #else
302 #define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()
303 #endif
304 #endif
305
306 // just an empty macro !
307 #define EIGEN_EMPTY
308
309 #if defined(_MSC_VER) && (!defined(__INTEL_COMPILER))
310 #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
311   using Base::operator =;
312 #else
313 #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
314   using Base::operator =; \
315   EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) \
316   { \
317     Base::operator=(other); \
318     return *this; \
319   }
320 #endif
321
322 #define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
323   EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)
324
325 /**
326 * Just a side note. Commenting within defines works only by documenting
327 * behind the object (via '!<'). Comments cannot be multi-line and thus
328 * we have these extra long lines. What is confusing doxygen over here is
329 * that we use '\' and basically have a bunch of typedefs with their
330 * documentation in a single line.
331 **/
332
333 #define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
334   typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
335   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. */ \
336   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. */ \
337   typedef typename Eigen::internal::nested<Derived>::type Nested; \
338   typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
339   typedef typename Eigen::internal::traits<Derived>::Index Index; \
340   enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
341         ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
342         Flags = Eigen::internal::traits<Derived>::Flags, \
343         CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \
344         SizeAtCompileTime = Base::SizeAtCompileTime, \
345         MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
346         IsVectorAtCompileTime = Base::IsVectorAtCompileTime };
347
348
349 #define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
350   typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
351   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. */ \
352   typedef typename Base::PacketScalar PacketScalar; \
353   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. */ \
354   typedef typename Eigen::internal::nested<Derived>::type Nested; \
355   typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
356   typedef typename Eigen::internal::traits<Derived>::Index Index; \
357   enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
358         ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
359         MaxRowsAtCompileTime = Eigen::internal::traits<Derived>::MaxRowsAtCompileTime, \
360         MaxColsAtCompileTime = Eigen::internal::traits<Derived>::MaxColsAtCompileTime, \
361         Flags = Eigen::internal::traits<Derived>::Flags, \
362         CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \
363         SizeAtCompileTime = Base::SizeAtCompileTime, \
364         MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
365         IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
366   using Base::derived; \
367   using Base::const_cast_derived;
368
369
370 #define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
371 #define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
372
373 // EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
374 // followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
375 // finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
376 #define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \
377                            : ((int)a == 1 || (int)b == 1) ? 1 \
378                            : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
379                            : ((int)a <= (int)b) ? (int)a : (int)b)
380
381 // EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values
382 // now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is
383 // (between 0 and 3), it is not more than 3.
384 #define EIGEN_SIZE_MIN_PREFER_FIXED(a,b)  (((int)a == 0 || (int)b == 0) ? 0 \
385                            : ((int)a == 1 || (int)b == 1) ? 1 \
386                            : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
387                            : ((int)a == Dynamic) ? (int)b \
388                            : ((int)b == Dynamic) ? (int)a \
389                            : ((int)a <= (int)b) ? (int)a : (int)b)
390
391 // see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here.
392 #define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
393                            : ((int)a >= (int)b) ? (int)a : (int)b)
394
395 #define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
396
397 #define EIGEN_IMPLIES(a,b) (!(a) || (b))
398
399 #define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \
400   template<typename OtherDerived> \
401   EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \
402   (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
403   { \
404     return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \
405   }
406
407 // the expression type of a cwise product
408 #define EIGEN_CWISE_PRODUCT_RETURN_TYPE(LHS,RHS) \
409     CwiseBinaryOp< \
410       internal::scalar_product_op< \
411           typename internal::traits<LHS>::Scalar, \
412           typename internal::traits<RHS>::Scalar \
413       >, \
414       const LHS, \
415       const RHS \
416     >
417
418 #endif // EIGEN_MACROS_H