Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / MatrixStorage.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-2009 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_MATRIXSTORAGE_H
27 #define EIGEN_MATRIXSTORAGE_H
28
29 struct ei_constructor_without_unaligned_array_assert {};
30
31 /** \internal
32   * Static array automatically aligned if the total byte size is a multiple of 16 and the matrix options require auto alignment
33   */
34 template <typename T, int Size, int MatrixOptions,
35           bool Align = (MatrixOptions&AutoAlign) && (((Size*sizeof(T))&0xf)==0)
36 > struct ei_matrix_array
37 {
38   EIGEN_ALIGN_128 T array[Size];
39
40   ei_matrix_array()
41   {
42     #ifndef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
43     ei_assert((reinterpret_cast<size_t>(array) & 0xf) == 0
44               && "this assertion is explained here: http://eigen.tuxfamily.org/dox/UnalignedArrayAssert.html  **** READ THIS WEB PAGE !!! ****");
45     #endif
46   }
47
48   ei_matrix_array(ei_constructor_without_unaligned_array_assert) {}
49 };
50
51 template <typename T, int Size, int MatrixOptions> struct ei_matrix_array<T,Size,MatrixOptions,false>
52 {
53   T array[Size];
54   ei_matrix_array() {}
55   ei_matrix_array(ei_constructor_without_unaligned_array_assert) {}
56 };
57
58 /** \internal
59   *
60   * \class ei_matrix_storage
61   *
62   * \brief Stores the data of a matrix
63   *
64   * This class stores the data of fixed-size, dynamic-size or mixed matrices
65   * in a way as compact as possible.
66   *
67   * \sa Matrix
68   */
69 template<typename T, int Size, int _Rows, int _Cols, int _Options> class ei_matrix_storage;
70
71 // purely fixed-size matrix
72 template<typename T, int Size, int _Rows, int _Cols, int _Options> class ei_matrix_storage
73 {
74     ei_matrix_array<T,Size,_Options> m_data;
75   public:
76     inline explicit ei_matrix_storage() {}
77     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
78       : m_data(ei_constructor_without_unaligned_array_assert()) {}
79     inline ei_matrix_storage(int,int,int) {}
80     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); }
81     inline static int rows(void) {return _Rows;}
82     inline static int cols(void) {return _Cols;}
83     inline void resize(int,int,int) {}
84     inline const T *data() const { return m_data.array; }
85     inline T *data() { return m_data.array; }
86 };
87
88 // dynamic-size matrix with fixed-size storage
89 template<typename T, int Size, int _Options> class ei_matrix_storage<T, Size, Dynamic, Dynamic, _Options>
90 {
91     ei_matrix_array<T,Size,_Options> m_data;
92     int m_rows;
93     int m_cols;
94   public:
95     inline explicit ei_matrix_storage() : m_rows(0), m_cols(0) {}
96     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
97       : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
98     inline ei_matrix_storage(int, int rows, int cols) : m_rows(rows), m_cols(cols) {}
99     inline ~ei_matrix_storage() {}
100     inline void swap(ei_matrix_storage& other)
101     { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
102     inline int rows(void) const {return m_rows;}
103     inline int cols(void) const {return m_cols;}
104     inline void resize(int, int rows, int cols)
105     {
106       m_rows = rows;
107       m_cols = cols;
108     }
109     inline const T *data() const { return m_data.array; }
110     inline T *data() { return m_data.array; }
111 };
112
113 // dynamic-size matrix with fixed-size storage and fixed width
114 template<typename T, int Size, int _Cols, int _Options> class ei_matrix_storage<T, Size, Dynamic, _Cols, _Options>
115 {
116     ei_matrix_array<T,Size,_Options> m_data;
117     int m_rows;
118   public:
119     inline explicit ei_matrix_storage() : m_rows(0) {}
120     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
121       : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {}
122     inline ei_matrix_storage(int, int rows, int) : m_rows(rows) {}
123     inline ~ei_matrix_storage() {}
124     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
125     inline int rows(void) const {return m_rows;}
126     inline int cols(void) const {return _Cols;}
127     inline void resize(int /*size*/, int rows, int)
128     {
129       m_rows = rows;
130     }
131     inline const T *data() const { return m_data.array; }
132     inline T *data() { return m_data.array; }
133 };
134
135 // dynamic-size matrix with fixed-size storage and fixed height
136 template<typename T, int Size, int _Rows, int _Options> class ei_matrix_storage<T, Size, _Rows, Dynamic, _Options>
137 {
138     ei_matrix_array<T,Size,_Options> m_data;
139     int m_cols;
140   public:
141     inline explicit ei_matrix_storage() : m_cols(0) {}
142     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
143       : m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {}
144     inline ei_matrix_storage(int, int, int cols) : m_cols(cols) {}
145     inline ~ei_matrix_storage() {}
146     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
147     inline int rows(void) const {return _Rows;}
148     inline int cols(void) const {return m_cols;}
149     inline void resize(int, int, int cols)
150     {
151       m_cols = cols;
152     }
153     inline const T *data() const { return m_data.array; }
154     inline T *data() { return m_data.array; }
155 };
156
157 // purely dynamic matrix.
158 template<typename T, int _Options> class ei_matrix_storage<T, Dynamic, Dynamic, Dynamic, _Options>
159 {
160     T *m_data;
161     int m_rows;
162     int m_cols;
163   public:
164     inline explicit ei_matrix_storage() : m_data(0), m_rows(0), m_cols(0) {}
165     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
166        : m_data(0), m_rows(0), m_cols(0) {}
167     inline ei_matrix_storage(int size, int rows, int cols)
168       : m_data(ei_aligned_new<T>(size)), m_rows(rows), m_cols(cols) {}
169     inline ~ei_matrix_storage() { ei_aligned_delete(m_data, m_rows*m_cols); }
170     inline void swap(ei_matrix_storage& other)
171     { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
172     inline int rows(void) const {return m_rows;}
173     inline int cols(void) const {return m_cols;}
174     void resize(int size, int rows, int cols)
175     {
176       if(size != m_rows*m_cols)
177       {
178         ei_aligned_delete(m_data, m_rows*m_cols);
179         if (size)
180           m_data = ei_aligned_new<T>(size);
181         else
182           m_data = 0;
183       }
184       m_rows = rows;
185       m_cols = cols;
186     }
187     inline const T *data() const { return m_data; }
188     inline T *data() { return m_data; }
189 };
190
191 // matrix with dynamic width and fixed height (so that matrix has dynamic size).
192 template<typename T, int _Rows, int _Options> class ei_matrix_storage<T, Dynamic, _Rows, Dynamic, _Options>
193 {
194     T *m_data;
195     int m_cols;
196   public:
197     inline explicit ei_matrix_storage() : m_data(0), m_cols(0) {}
198     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
199     inline ei_matrix_storage(int size, int, int cols) : m_data(ei_aligned_new<T>(size)), m_cols(cols) {}
200     inline ~ei_matrix_storage() { ei_aligned_delete(m_data, _Rows*m_cols); }
201     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
202     inline static int rows(void) {return _Rows;}
203     inline int cols(void) const {return m_cols;}
204     void resize(int size, int, int cols)
205     {
206       if(size != _Rows*m_cols)
207       {
208         ei_aligned_delete(m_data, _Rows*m_cols);
209         if (size)
210           m_data = ei_aligned_new<T>(size);
211         else
212           m_data = 0;
213       }
214       m_cols = cols;
215     }
216     inline const T *data() const { return m_data; }
217     inline T *data() { return m_data; }
218 };
219
220 // matrix with dynamic height and fixed width (so that matrix has dynamic size).
221 template<typename T, int _Cols, int _Options> class ei_matrix_storage<T, Dynamic, Dynamic, _Cols, _Options>
222 {
223     T *m_data;
224     int m_rows;
225   public:
226     inline explicit ei_matrix_storage() : m_data(0), m_rows(0) {}
227     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
228     inline ei_matrix_storage(int size, int rows, int) : m_data(ei_aligned_new<T>(size)), m_rows(rows) {}
229     inline ~ei_matrix_storage() { ei_aligned_delete(m_data, _Cols*m_rows); }
230     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
231     inline int rows(void) const {return m_rows;}
232     inline static int cols(void) {return _Cols;}
233     void resize(int size, int rows, int)
234     {
235       if(size != m_rows*_Cols)
236       {
237         ei_aligned_delete(m_data, _Cols*m_rows);
238         if (size)
239           m_data = ei_aligned_new<T>(size);
240         else
241           m_data = 0;
242       }
243       m_rows = rows;
244     }
245     inline const T *data() const { return m_data; }
246     inline T *data() { return m_data; }
247 };
248
249 #endif // EIGEN_MATRIX_H