Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / util / Constants.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra. Eigen itself is part of the KDE project.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <g.gael@free.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_CONSTANTS_H
27 #define EIGEN_CONSTANTS_H
28
29 /** This value means that a quantity is not known at compile-time, and that instead the value is
30   * stored in some runtime variable.
31   *
32   * Explanation for the choice of this value:
33   * - It should be positive and larger than any reasonable compile-time-fixed number of rows or columns.
34   *   This allows to simplify many compile-time conditions throughout Eigen.
35   * - It should be smaller than the sqrt of INT_MAX. Indeed, we often multiply a number of rows with a number
36   *   of columns in order to compute a number of coefficients. Even if we guard that with an "if" checking whether
37   *   the values are Dynamic, we still get a compiler warning "integer overflow". So the only way to get around
38   *   it would be a meta-selector. Doing this everywhere would reduce code readability and lenghten compilation times.
39   *   Also, disabling compiler warnings for integer overflow, sounds like a bad idea.
40   *
41   * If you wish to port Eigen to a platform where sizeof(int)==2, it is perfectly possible to set Dynamic to, say, 100.
42   */
43 const int Dynamic = 10000;
44
45 /** This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>().
46   * The value Infinity there means the L-infinity norm.
47   */
48 const int Infinity = -1;
49
50 /** \defgroup flags flags
51   * \ingroup Core_Module
52   *
53   * These are the possible bits which can be OR'ed to constitute the flags of a matrix or
54   * expression.
55   *
56   * It is important to note that these flags are a purely compile-time notion. They are a compile-time property of
57   * an expression type, implemented as enum's. They are not stored in memory at runtime, and they do not incur any
58   * runtime overhead.
59   *
60   * \sa MatrixBase::Flags
61   */
62
63 /** \ingroup flags
64   *
65   * for a matrix, this means that the storage order is row-major.
66   * If this bit is not set, the storage order is column-major.
67   * For an expression, this determines the storage order of
68   * the matrix created by evaluation of that expression. */
69 const unsigned int RowMajorBit = 0x1;
70
71 /** \ingroup flags
72   *
73   * means the expression should be evaluated by the calling expression */
74 const unsigned int EvalBeforeNestingBit = 0x2;
75
76 /** \ingroup flags
77   *
78   * means the expression should be evaluated before any assignement */
79 const unsigned int EvalBeforeAssigningBit = 0x4;
80
81 /** \ingroup flags
82   *
83   * Short version: means the expression might be vectorized
84   *
85   * Long version: means that the coefficients can be handled by packets
86   * and start at a memory location whose alignment meets the requirements
87   * of the present CPU architecture for optimized packet access. In the fixed-size
88   * case, there is the additional condition that the total size of the coefficients
89   * array is a multiple of the packet size, so that it is possible to access all the
90   * coefficients by packets. In the dynamic-size case, there is no such condition
91   * on the total size, so it might not be possible to access the few last coeffs
92   * by packets.
93   *
94   * \note This bit can be set regardless of whether vectorization is actually enabled.
95   *       To check for actual vectorizability, see \a ActualPacketAccessBit.
96   */
97 const unsigned int PacketAccessBit = 0x8;
98
99 #ifdef EIGEN_VECTORIZE
100 /** \ingroup flags
101   *
102   * If vectorization is enabled (EIGEN_VECTORIZE is defined) this constant
103   * is set to the value \a PacketAccessBit.
104   *
105   * If vectorization is not enabled (EIGEN_VECTORIZE is not defined) this constant
106   * is set to the value 0.
107   */
108 const unsigned int ActualPacketAccessBit = PacketAccessBit;
109 #else
110 const unsigned int ActualPacketAccessBit = 0x0;
111 #endif
112
113 /** \ingroup flags
114   *
115   * Short version: means the expression can be seen as 1D vector.
116   *
117   * Long version: means that one can access the coefficients
118   * of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These
119   * index-based access methods are guaranteed
120   * to not have to do any runtime computation of a (row, col)-pair from the index, so that it
121   * is guaranteed that whenever it is available, index-based access is at least as fast as
122   * (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.
123   *
124   * If both PacketAccessBit and LinearAccessBit are set, then the
125   * packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a
126   * lvalue expression.
127   *
128   * Typically, all vector expressions have the LinearAccessBit, but there is one exception:
129   * Product expressions don't have it, because it would be troublesome for vectorization, even when the
130   * Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but
131   * not index-based packet access, so they don't have the LinearAccessBit.
132   */
133 const unsigned int LinearAccessBit = 0x10;
134
135 /** \ingroup flags
136   *
137   * Means that the underlying array of coefficients can be directly accessed. This means two things.
138   * First, references to the coefficients must be available through coeffRef(int, int). This rules out read-only
139   * expressions whose coefficients are computed on demand by coeff(int, int). Second, the memory layout of the
140   * array of coefficients must be exactly the natural one suggested by rows(), cols(), stride(), and the RowMajorBit.
141   * This rules out expressions such as DiagonalCoeffs, whose coefficients, though referencable, do not have
142   * such a regular memory layout.
143   */
144 const unsigned int DirectAccessBit = 0x20;
145
146 /** \ingroup flags
147   *
148   * means the first coefficient packet is guaranteed to be aligned */
149 const unsigned int AlignedBit = 0x40;
150
151 /** \ingroup flags
152   *
153   * means all diagonal coefficients are equal to 0 */
154 const unsigned int ZeroDiagBit = 0x80;
155
156 /** \ingroup flags
157   *
158   * means all diagonal coefficients are equal to 1 */
159 const unsigned int UnitDiagBit = 0x100;
160
161 /** \ingroup flags
162   *
163   * means the matrix is selfadjoint (M=M*). */
164 const unsigned int SelfAdjointBit = 0x200;
165
166 /** \ingroup flags
167   *
168   * means the strictly lower triangular part is 0 */
169 const unsigned int UpperTriangularBit = 0x400;
170
171 /** \ingroup flags
172   *
173   * means the strictly upper triangular part is 0 */
174 const unsigned int LowerTriangularBit = 0x800;
175
176 /** \ingroup flags
177   *
178   * means the expression includes sparse matrices and the sparse path has to be taken. */
179 const unsigned int SparseBit = 0x1000;
180
181 // list of flags that are inherited by default
182 const unsigned int HereditaryBits = RowMajorBit
183                                   | EvalBeforeNestingBit
184                                   | EvalBeforeAssigningBit
185                                   | SparseBit;
186
187 // Possible values for the Mode parameter of part() and of extract()
188 const unsigned int UpperTriangular = UpperTriangularBit;
189 const unsigned int StrictlyUpperTriangular = UpperTriangularBit | ZeroDiagBit;
190 const unsigned int LowerTriangular = LowerTriangularBit;
191 const unsigned int StrictlyLowerTriangular = LowerTriangularBit | ZeroDiagBit;
192 const unsigned int SelfAdjoint = SelfAdjointBit;
193
194 // additional possible values for the Mode parameter of extract()
195 const unsigned int UnitUpperTriangular = UpperTriangularBit | UnitDiagBit;
196 const unsigned int UnitLowerTriangular = LowerTriangularBit | UnitDiagBit;
197 const unsigned int Diagonal = UpperTriangular | LowerTriangular;
198
199 enum { Aligned, Unaligned };
200 enum { ForceAligned, AsRequested };
201 enum { ConditionalJumpCost = 5 };
202 enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };
203 enum DirectionType { Vertical, Horizontal };
204 enum ProductEvaluationMode { NormalProduct, CacheFriendlyProduct, DiagonalProduct, SparseTimeSparseProduct, SparseTimeDenseProduct, DenseTimeSparseProduct };
205
206 enum {
207   /** \internal Equivalent to a slice vectorization for fixed-size matrices having good alignment
208     * and good size */
209   InnerVectorization,
210   /** \internal Vectorization path using a single loop plus scalar loops for the
211     * unaligned boundaries */
212   LinearVectorization,
213   /** \internal Generic vectorization path using one vectorized loop per row/column with some
214     * scalar loops to handle the unaligned boundaries */
215   SliceVectorization,
216   NoVectorization
217 };
218
219 enum {
220   NoUnrolling,
221   InnerUnrolling,
222   CompleteUnrolling
223 };
224
225 enum {
226   ColMajor = 0,
227   RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
228   /** \internal Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be
229                 requested to be aligned) */
230   DontAlign = 0,
231   /** \internal Align the matrix itself if it is vectorizable fixed-size */
232   AutoAlign = 0x2
233 };
234
235 enum {
236   IsDense         = 0,
237   IsSparse        = SparseBit,
238   NoDirectAccess  = 0,
239   HasDirectAccess = DirectAccessBit
240 };
241
242 const int EiArch_Generic = 0x0;
243 const int EiArch_SSE     = 0x1;
244 const int EiArch_AltiVec = 0x2;
245
246 #if defined EIGEN_VECTORIZE_SSE
247   const int EiArch = EiArch_SSE;
248 #elif defined EIGEN_VECTORIZE_ALTIVEC
249   const int EiArch = EiArch_AltiVec;
250 #else
251   const int EiArch = EiArch_Generic;
252 #endif
253
254 #endif // EIGEN_CONSTANTS_H