MatrixXX.h
Go to the documentation of this file.
3 #ifndef _USE_MATH_DEFINES
4 #define _USE_MATH_DEFINES
5 #endif
6 #include <cmath>
7 #include <iostream>
8 #include <algorithm>
9 #include <GfxTL/StdOverrides.h>
10 #ifdef min
11 #undef min
12 #endif
13 #ifdef max
14 #undef max
15 #endif
16
17 namespace GfxTL
18 {
19  // forward declaration
20  template< unsigned int D, class T >
21  class VectorXD;
22
23  // forward declaration
24  template< unsigned int C, unsigned int R, class T >
25  class MatrixXX;
26
27  // matrix operators
28  template< unsigned int C, unsigned int R, class T >
30  template< unsigned int C, unsigned int R, class T >
32  template< unsigned int C, unsigned int R, class T >
34  template< unsigned int C, unsigned int R, class T >
36  template< unsigned int C, unsigned int R, class T >
38  template< unsigned int C, unsigned int R, class T >
39  bool operator==(const MatrixXX< C, R, T >& a, const MatrixXX< C, R, T >& b);
40  template< unsigned int C, unsigned int R, class T >
41  bool operator!=(const MatrixXX< C, R, T >& a, const MatrixXX< C, R, T >& b);
42
43  namespace Internal
44  {
45  /** Matrix in column major order */
46  template< unsigned int C, unsigned int R, class T >
48  {
49  public:
50  typedef T ScalarType;
51  typedef T value_type;
53  enum { Rows = R, Cols = C, Entries = C * R };
54
55  VectorXD< R, T >& operator[](unsigned int col)
56  {
57  return *(reinterpret_cast< VectorXD< R, T > * >(&_m[col * R]));
58  }
59
60  const VectorXD< R, T >& operator[](unsigned int col) const
61  {
62  return *(reinterpret_cast< const VectorXD< R, T > * >(&_m[col * R]));
63  }
64
65  void Zero()
66  {
67  memset(_m, 0, sizeof(_m));
68  }
69
70  T* Data()
71  {
72  return _m;
73  }
74
75  const T* Data() const
76  {
77  return _m;
78  }
79
81  {
82  T s = 0;
83  for (unsigned int i = 0; i < C * R; ++i)
84  {
85  s += _m[i] * _m[i];
86  }
87  if (s == 0)
88  {
89  return s;
90  }
91  s = T(std::sqrt(s));
92  for (unsigned int i = 0; i < C * R; ++i)
93  {
94  _m[i] /= s;
95  }
96  return s;
97  }
98
100  {
101  for (unsigned int c = 0; c < C; ++c)
102  for (unsigned int r = 0; r < R; ++r)
103  {
104  (*t)[r][c] = (*this)[c][r];
105  }
106  }
107
108  protected:
110  };
111  };
112
113  // matrix class
114  template< unsigned int C, unsigned int R, class T >
115  class MatrixXX
116  : public Internal::BaseMatrixXX< C, R, T >
117  {
118  public:
122
123  MatrixXX() {}
124
125  MatrixXX(const SuperType& mat)
126  : SuperType(mat)
127  {}
128
129  MatrixXX(const ThisType& mat)
130  {
131  memcpy(SuperType::_m, mat._m, sizeof(SuperType::_m));
132  }
133
134  explicit MatrixXX(T v)
135  {
136  for (unsigned int i = 0; i < SuperType::Entries; ++i)
137  {
138  SuperType::_m[i] = v;
139  }
140  }
141
142  explicit MatrixXX(const T* m)
143  {
144  memcpy(SuperType::_m, m, sizeof(SuperType::_m));
145  }
146
148  {
150  (*this)[0] = a;
151  (*this)[1] = b;
152  }
153
155  const MatrixXX< 1, R, T >& c)
156  {
158  (*this)[0] = a;
159  (*this)[1] = b;
160  (*this)[2] = c;
161  }
162
164  const MatrixXX< 1, R, T >& c, const MatrixXX< 1, R, T >& d)
165  {
167  (*this)[0] = a;
168  (*this)[1] = b;
169  (*this)[2] = c;
170  (*this)[3] = c;
171  }
172
174  {
175  for (unsigned int i = 0; i < SuperType::Entries; ++i)
176  {
177  SuperType::_m[i] = v;
178  }
179  return *this;
180  }
181
183  {
184  for (unsigned int i = 0; i < SuperType::Entries; ++i)
185  {
186  SuperType::_m[i] = v._m[i];
187  }
188  return *this;
189  }
190
192  {
193  for (unsigned int i = 0; i < SuperType::Entries; ++i)
194  {
195  SuperType::_m[i] *= a._m[i];
196  }
197  return *this;
198  }
199
201  {
202  TransposedType t;
204  return t;
205  }
206
207  protected:
208  template< unsigned int A, unsigned int B >
209  struct AssertDim
210  {
211  static inline void AssertEqual()
212  {
213 #ifdef WIN32
214  Error_InvalidDimension();
215 #else
216  exit(123);
217 #endif
218  }
219  };
220
221  template< unsigned int A >
222  struct AssertDim< A, A >
223  {
224  static inline void AssertEqual() {}
225  };
226  };
227
228  // matrix specialization
229  template< class T >
230  class MatrixXX< 1, 1, T >
231  : public Internal::BaseMatrixXX< 1, 1, T >
232  {
233  public:
237
238  MatrixXX() {}
239
240  MatrixXX(const SuperType& mat)
241  : SuperType(mat)
242  {}
243
245  {
246  memcpy(SuperType::_m, mat._m, sizeof(SuperType::_m));
247  }
248
250  {
251  SuperType::_m[0] = v;
252  }
253
254  explicit MatrixXX(const T* m)
255  {
256  memcpy(SuperType::_m, m, sizeof(SuperType::_m));
257  }
258
260  {
261  SuperType::_m[0] = v;
262  return *this;
263  }
264
266  {
267  for (unsigned int i = 0; i < SuperType::Entries; ++i)
268  {
269  SuperType::_m[i] *= a._m[i];
270  }
271  return *this;
272  }
273
274  operator const T() const
275  {
276  return SuperType::_m[0];
277  }
278
279  operator T& ()
280  {
281  return SuperType::_m[0];
282  }
283  };
284
285  // matrix operator implemenation
286  template< unsigned int C, unsigned int R, class T >
288  {
289  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
290  {
291  m.Data()[i] += b.Data()[i];
292  }
293  return m;
294  }
295
296  template< unsigned int C, unsigned int R, class T >
298  {
299  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
300  {
301  m.Data()[i] -= b.Data()[i];
302  }
303  return m;
304  }
305
306  template< unsigned int C, unsigned int R, class T >
308  {
309  m = m * b;
310  return m;
311  }
312
313  template< unsigned int C, unsigned int R, class T >
315  {
316  return m *= (const T)b;
317  }
318
319  template< unsigned int C, unsigned int R, class T >
321  {
322  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
323  {
324  m.Data()[i] *= s;
325  }
326  return m;
327  }
328
329  template< unsigned int C, unsigned int R, class T >
331  {
332  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
333  {
334  m.Data()[i] /= s;
335  }
336  return m;
337  }
338
339  template< unsigned int C, unsigned int R, class T >
341  {
343  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
344  {
345  m.Data()[i] = typename MatrixXX< C, R, T >::ScalarType(-1) * a.Data()[i];
346  }
347  return m;
348  }
349
350  template< unsigned int C, unsigned int R, class T >
351  inline bool operator==(const MatrixXX< C, R, T >& a,
352  const MatrixXX< C, R, T >& b)
353  {
354  return memcmp(a.Data(), b.Data(), sizeof(a)) == 0;
355  }
356
357  template< unsigned int C, unsigned int R, class T >
358  inline bool operator!=(const MatrixXX< C, R, T >& a, const MatrixXX< C, R, T >& b)
359  {
360  return memcmp(a.Data(), b.Data(), sizeof(a)) != 0;
361  }
362
363  template< unsigned int C, unsigned int R, class T >
365  const MatrixXX< C, R, T >& b)
366  {
368  c.ComponentMul(b);
369  return c;
370  }
371
372  template< unsigned int C, unsigned int R, class T >
374  {
375  return ComponentMul(a, a);
376  }
377
378  template< unsigned int C, unsigned int R, class T >
380  {
382  c *= s;
383  return c;
384  }
385
386  // matrix multiplication
387  template< unsigned int C, unsigned int R, unsigned int C2, class T >
389  const MatrixXX< C2, C, T >& b)
390  {
392  for (int c = 0; c < C2; ++c)
393  {
394  for (int r = 0; r < R; ++r)
395  {
396  x[c][r] = a[0][r] * b[c][0];
397  for (int i = 1; i < C; ++i)
398  {
399  x[c][r] += a[i][r] * b[c][i];
400  }
401  }
402  }
403  return x;
404  }
405
406  template< unsigned int C, unsigned int R, class T >
408  const MatrixXX< C, R, T >& b)
409  {
410  return ((const T)a) * b;
411  }
412
413  template< unsigned int C, unsigned int R, class T >
415  const MatrixXX< C, R, T >& b)
416  {
418  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
419  {
420  c.Data()[i] = a.Data()[i] + b.Data()[i];
421  }
422  return c;
423  }
424
425  template< unsigned int C, unsigned int R, class T >
427  const MatrixXX< C, R, T >& b)
428  {
430  for (unsigned int i = 0; i < MatrixXX< C, R, T >::Entries; ++i)
431  {
432  c.Data()[i] = a.Data()[i] - b.Data()[i];
433  }
434  return c;
435  }
436
437  template< unsigned int N, class T >
438  inline T Trace(const MatrixXX< N, N, T >& a)
439  {
440  T t = 0;
441  for (unsigned int i = 0; i < N; ++i)
442  {
443  t += a[i][i];
444  }
445  return t;
446  }
447
448  template< unsigned int N, class T >
450  {
451  T t = 0;
452  for (unsigned int i = 0; i < N; ++i)
453  {
454  if (a[i][i] > 0)
455  {
456  t += a[i][i];
457  }
458  else
459  {
460  t -= a[i][i];
461  }
462  }
463  return t;
464  }
465
466  // this is a rather slow O(n!) algorithm!
467  // it is only suitable for small matrices!
468  // larger matrices should use LU decomposition
469  template< unsigned int N, class T >
471  {
472  int j = 1;
473  T det = 0;
474  for (unsigned int i = 0; i < N; ++i, j *= -1)
475  {
476  MatrixXX < N - 1, N - 1, T > m;
477  for (unsigned int k = 1, kk = 0; kk < N - 1; ++kk, ++k)
478  {
479  for (unsigned int l = 0, ll = 0; ll < N - 1; ++ll, ++l)
480  {
481  if (l == i)
482  {
483  ++l;
484  }
485  m[ll][kk] = a[l][k];
486  }
487  }
488  det += j * Determinant(m);
489  }
490  return det;
491  }
492
493  template< class T >
495  {
496  return a[0][0] * (a[1][1] * a[2][2] - a[1][2] * a[2][1])
497  - a[0][1] * (a[1][0] * a[2][2] - a[1][2] * a[2][0])
498  + a[0][2] * (a[1][0] * a[2][1] - a[1][1] * a[2][0]);
499  }
500
501  template< class T >
503  {
504  return a[0][0] * a[1][1] - a[1][0] * a[0][1];
505  }
506
507  template< class T >
509  {
510  return a[0][0];
511  }
512
513  template< class T >
514  inline void Rotation(T rad, MatrixXX< 2, 2, T >* a)
515  {
518  (*a)[1][0] = -(*a)[0][1];
519  (*a)[1][1] = (*a)[0][0];
520  }
521
522  template< unsigned int N, class T >
524  {
525  for (unsigned int c = 0; c < N; ++c)
526  {
527  unsigned int r = 0;
528  for (; r < c; ++r)
529  {
530  (*a)[c][r] = 0;
531  }
532  (*a)[c][r] = 1;
533  for (++r; r < N; ++r)
534  {
535  (*a)[c][r] = 0;
536  }
537  }
538  }
539
540  template< unsigned int N, class T >
542  : public MatrixXX< N, N, T >
543  {
544  public:
546  {
547  Identity(this);
548  }
549  };
550
551  template< unsigned int C, unsigned int R, class T >
552  std::ostream& operator<<(std::ostream& o, const MatrixXX< C, R, T >& mat)
553  {
554  o << "[";
555  for (unsigned int i = 0; i < C; ++i)
556  {
557  o << mat[i];
558  if (i < C - 1)
559  {
560  o << ", ";
561  }
562  }
563  o << "]";
564  return o;
565  }
566
567  template< unsigned int C, unsigned int R, class T >
569  {
570  using namespace std;
572  for (unsigned int c = 0; c < C; ++c)
573  for (unsigned int r = 0; r < R; ++r)
574  {
575  m[c][r] = min(a[c][r], b[c][r]);
576  }
577  return m;
578  }
579
580  template< unsigned int C, unsigned int R, class T >
582  {
583  using namespace std;
585  for (unsigned int c = 0; c < C; ++c)
586  for (unsigned int r = 0; r < R; ++r)
587  {
588  m[c][r] = max(a[c][r], b[c][r]);
589  }
590  return m;
591  }
592
602
603 };
604
605 #include <GfxTL/VectorXD.h>
606
607 #endif
GfxTL::sqrt
VectorXD< D, T > sqrt(const VectorXD< D, T > &a)
Definition: VectorXD.h:662
GfxTL::MatrixXX::operator=
ThisType & operator=(const ThisType &v)
Definition: MatrixXX.h:182
GfxTL::VectorXD
Definition: MatrixXX.h:21
GfxTL::IdentityMatrixX::IdentityMatrixX
IdentityMatrixX()
Definition: MatrixXX.h:545
GfxTL::MatrixXX< 1, 1, T >::MatrixXX
MatrixXX(const MatrixXX< 1, 1, T > &mat)
Definition: MatrixXX.h:244
GfxTL::MatrixXX::MatrixXX
MatrixXX(const T *m)
Definition: MatrixXX.h:142
GfxTL::Internal::BaseMatrixXX::operator[]
VectorXD< R, T > & operator[](unsigned int col)
Definition: MatrixXX.h:55
GfxTL::MatrixXX< 1, 1, T >::TransposedType
MatrixXX< 1, 1, T > TransposedType
Definition: MatrixXX.h:236
GfxTL::Internal::BaseMatrixXX::Cols
@ Cols
Definition: MatrixXX.h:53
GfxTL::Internal::BaseMatrixXX::Data
T * Data()
Definition: MatrixXX.h:70
GfxTL::max
MatrixXX< C, R, T > max(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:581
GfxTL::MatrixXX::SuperType
Internal::BaseMatrixXX< C, R, T > SuperType
Definition: MatrixXX.h:119
GfxTL::MatrixXX::MatrixXX
MatrixXX(const MatrixXX< 1, R, T > &a, const MatrixXX< 1, R, T > &b, const MatrixXX< 1, R, T > &c, const MatrixXX< 1, R, T > &d)
Definition: MatrixXX.h:163
GfxTL::MatrixXX::ThisType
MatrixXX< C, R, T > ThisType
Definition: MatrixXX.h:120
GfxTL::MatrixXX::MatrixXX
MatrixXX(const SuperType &mat)
Definition: MatrixXX.h:125
c
constexpr T c
Definition: UnscentedKalmanFilterTest.cpp:43
GfxTL::MatrixXX< 1, 1, T >::operator=
ThisType & operator=(T v)
Definition: MatrixXX.h:259
GfxTL::min
MatrixXX< C, R, T > min(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:568
GfxTL::Internal::BaseMatrixXX::Rows
@ Rows
Definition: MatrixXX.h:53
GfxTL::MatrixXX::MatrixXX
MatrixXX()
Definition: MatrixXX.h:123
GfxTL::operator==
bool operator==(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:351
GfxTL::Internal::BaseMatrixXX::value_type
T value_type
Definition: MatrixXX.h:51
GfxTL::MatrixXX
Definition: MatrixXX.h:25
GfxTL::Internal::BaseMatrixXX::Data
const T * Data() const
Definition: MatrixXX.h:75
GfxTL::operator/=
MatrixXX< C, R, T > & operator/=(MatrixXX< C, R, T > &m, T s)
Definition: MatrixXX.h:330
VectorXD.h
GfxTL::operator*=
MatrixXX< C, R, T > & operator*=(MatrixXX< C, R, T > &m, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:307
GfxTL::Internal::BaseMatrixXX::_m
T _m[Entries]
Definition: MatrixXX.h:109
GfxTL::MatrixXX::AssertDim< A, A >::AssertEqual
static void AssertEqual()
Definition: MatrixXX.h:224
GfxTL::operator+=
MatrixXX< C, R, T > & operator+=(MatrixXX< C, R, T > &m, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:287
GfxTL::MatrixXX::AssertDim
Definition: MatrixXX.h:209
GfxTL::Internal::BaseMatrixXX::operator[]
const VectorXD< R, T > & operator[](unsigned int col) const
Definition: MatrixXX.h:60
GfxTL::MatrixXX< 1, 1, T >::MatrixXX
MatrixXX(const T *m)
Definition: MatrixXX.h:254
GfxTL::Internal::BaseMatrixXX
Matrix in column major order.
Definition: MatrixXX.h:47
GfxTL::Identity
void Identity(MatrixXX< N, N, T > *a)
Definition: MatrixXX.h:523
armarx::ctrlutil::a
double a(double t, double a0, double j)
Definition: CtrlUtil.h:45
GfxTL::operator<<
std::ostream & operator<<(std::ostream &o, const Array< DimT, IteratorT > &a)
Definition: Array.h:166
GfxTL::operator!=
bool operator!=(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:358
GfxTL::SqrComponentMul
const MatrixXX< C, R, T > SqrComponentMul(const MatrixXX< C, R, T > &a)
Definition: MatrixXX.h:373
GfxTL::Matrix2f
MatrixXX< 2, 2, float > Matrix2f
Definition: MatrixXX.h:599
GfxTL::Mat3f
MatrixXX< 3, 3, float > Mat3f
Definition: MatrixXX.h:597
GfxTL::MatrixXX::operator=
ThisType & operator=(T v)
Definition: MatrixXX.h:173
GfxTL::MatrixXX::MatrixXX
MatrixXX(T v)
Definition: MatrixXX.h:134
GfxTL::MatrixXX< 1, 1, T >::SuperType
Internal::BaseMatrixXX< 1, 1, T > SuperType
Definition: MatrixXX.h:234
GfxTL::MatrixXX::MatrixXX
MatrixXX(const MatrixXX< 1, R, T > &a, const MatrixXX< 1, R, T > &b, const MatrixXX< 1, R, T > &c)
Definition: MatrixXX.h:154
GfxTL::MatrixXX::MatrixXX
MatrixXX(const ThisType &mat)
Definition: MatrixXX.h:129
GfxTL::MatrixXX::Transposed
TransposedType Transposed()
Definition: MatrixXX.h:200
GfxTL::Internal::BaseMatrixXX::ThisType
BaseMatrixXX< C, R, T > ThisType
Definition: MatrixXX.h:52
GfxTL::TraceAbs
T TraceAbs(const MatrixXX< N, N, T > &a)
Definition: MatrixXX.h:449
GfxTL::Rotation
void Rotation(T rad, MatrixXX< 2, 2, T > *a)
Definition: MatrixXX.h:514
GfxTL::operator*
const MatrixXX< C, R, T > operator*(T s, const MatrixXX< C, R, T > &a)
Definition: MatrixXX.h:379
GfxTL::Internal::BaseMatrixXX::ScalarType
T ScalarType
Definition: MatrixXX.h:50
GfxTL::Internal::BaseMatrixXX::Transpose
void Transpose(BaseMatrixXX< R, C, T > *t) const
Definition: MatrixXX.h:99
GfxTL::Mat4f
MatrixXX< 4, 4, float > Mat4f
Definition: MatrixXX.h:598
GfxTL
Definition: AABox.h:8
GfxTL::Determinant
T Determinant(const MatrixXX< N, N, T > &a)
Definition: MatrixXX.h:470
GfxTL::Trace
T Trace(const MatrixXX< N, N, T > &a)
Definition: MatrixXX.h:438
GfxTL::MatrixXX< 1, 1, T >::MatrixXX
MatrixXX(T v)
Definition: MatrixXX.h:249
GfxTL::Internal::BaseMatrixXX::Entries
@ Entries
Definition: MatrixXX.h:53
GfxTL::MatrixXX::MatrixXX
MatrixXX(const MatrixXX< 1, R, T > &a, const MatrixXX< 1, R, T > &b)
Definition: MatrixXX.h:147
A
class A(deque< T, A >)) ARMARX_OVERLOAD_STD_HASH_FOR_ITERABLE((class T
Enables hashing of std::list.
GfxTL::MatrixXX< 1, 1, T >::MatrixXX
MatrixXX(const SuperType &mat)
Definition: MatrixXX.h:240
GfxTL::mat3
MatrixXX< 3, 3, float > mat3
Definition: MatrixXX.h:594
armarx::ctrlutil::v
double v(double t, double v0, double a0, double j)
Definition: CtrlUtil.h:39
GfxTL::Matrix3f
MatrixXX< 3, 3, float > Matrix3f
Definition: MatrixXX.h:600
GfxTL::Matrix4f
MatrixXX< 4, 4, float > Matrix4f
Definition: MatrixXX.h:601
GfxTL::Internal::BaseMatrixXX::Zero
void Zero()
Definition: MatrixXX.h:65
GfxTL::MatrixXX< 1, 1, T >::ComponentMul
MatrixXX< 1, 1, T > & ComponentMul(const MatrixXX< 1, 1, T > &a)
Definition: MatrixXX.h:265
GfxTL::ComponentMul
const MatrixXX< C, R, T > ComponentMul(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:364
std
Definition: Application.h:66
GfxTL::MatrixXX::AssertDim::AssertEqual
static void AssertEqual()
Definition: MatrixXX.h:211
GfxTL::operator+
const MatrixXX< C, R, T > operator+(const MatrixXX< C, R, T > &a, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:414
GfxTL::operator-=
MatrixXX< C, R, T > & operator-=(MatrixXX< C, R, T > &m, const MatrixXX< C, R, T > &b)
Definition: MatrixXX.h:297
GfxTL::Mat2f
MatrixXX< 2, 2, float > Mat2f
Definition: MatrixXX.h:596
T
float T
Definition: UnscentedKalmanFilterTest.cpp:35
StdOverrides.h
GfxTL::Internal::BaseMatrixXX::Normalize
T Normalize()
Definition: MatrixXX.h:80
GfxTL::MatrixXX::TransposedType
MatrixXX< R, C, T > TransposedType
Definition: MatrixXX.h:121
GfxTL::MatrixXX< 1, 1, T >::MatrixXX
MatrixXX()
Definition: MatrixXX.h:238
GfxTL::mat4
MatrixXX< 4, 4, float > mat4
Definition: MatrixXX.h:595
GfxTL::operator-
MatrixXX< C, R, T > operator-(const MatrixXX< C, R, T > &a)
Definition: MatrixXX.h:340
GfxTL::IdentityMatrixX
Definition: MatrixXX.h:541
GfxTL::MatrixXX< 1, 1, T >
Definition: MatrixXX.h:230
GfxTL::MatrixXX< 1, 1, T >::ThisType
MatrixXX< 1, 1, T > ThisType
Definition: MatrixXX.h:235
armarx::ctrlutil::s
double s(double t, double s0, double v0, double a0, double j)
Definition: CtrlUtil.h:33
GfxTL::MatrixXX::ComponentMul
MatrixXX< C, R, T > & ComponentMul(const MatrixXX< C, R, T > &a)
Definition: MatrixXX.h:191
GfxTL::mat2
MatrixXX< 2, 2, float > mat2
Definition: MatrixXX.h:593