ML Reference
mlMatrix5.h
Go to the documentation of this file.
1/*************************************************************************************
2**
3** Copyright 2007, MeVis Medical Solutions AG
4**
5** The user may use this file in accordance with the license agreement provided with
6** the Software or, alternatively, in accordance with the terms contained in a
7** written agreement between the user and MeVis Medical Solutions AG.
8**
9** For further information use the contact form at https://www.mevislab.de/contact
10**
11**************************************************************************************/
12
13#ifndef ML_MATRIX5_H
14#define ML_MATRIX5_H
15
17
18// Include system independent file and project settings.
19#include "mlLinearAlgebraSystem.h"
20#include "mlLinearAlgebraDefs.h"
21
22
23#include "mlFloatingPointMatrix.h"
24
25#include "mlVector5.h"
26
27#include "mlMatrix4.h"
28
29#include <mlErrorMacros.h>
30#include <mlErrorOutput.h>
31
32// All declarations of this header will be in the ML_LINEAR_ALGEBRA namespace.
33ML_LA_START_NAMESPACE
34//--------------------------------------------------------------------
36// This is necessary because we do not know whether vector or
37// matrix header is included first and we cannot move template
38// code into the C++ file.
39//--------------------------------------------------------------------
40template <class DT> class Tvec5;
41template <class DT> class Tmat4;
43
44//--------------------------------------------------------------------
46//--------------------------------------------------------------------
47template <class DT>
48class Tmat5 : public FloatingPointMatrix<Tvec5<DT>, 5>
49{
50public:
51
53 typedef DT ComponentType;
54
56 Tmat5();
57
59 Tmat5(const DT diagValue);
60
62 Tmat5(const Tvec5<DT> &row0, const Tvec5<DT> &row1, const Tvec5<DT> &row2,
63 const Tvec5<DT> &row3, const Tvec5<DT> &row4);
64
66 Tmat5(const Tmat5<DT> &mat);
67
69 Tmat5(const float mat[25]);
70
72 Tmat5(const double mat[25]);
73
76 Tmat5(const double in00, const double in01, const double in02, const double in03, const double in04,
77 const double in10, const double in11, const double in12, const double in13, const double in14,
78 const double in20, const double in21, const double in22, const double in23, const double in24,
79 const double in30, const double in31, const double in32, const double in33, const double in34,
80 const double in40, const double in41, const double in42, const double in43, const double in44);
81
84 void setValues(const float m[25]);
85
90 void getValues(float m[25]) const;
91
94 void setValues(const double m[25]);
95
98 void getValues(double m[25]) const;
99
101 void setScaleMatrix(const DT scale);
102
104 static Tmat5<DT> getMat(const double val);
105
107 void set(const DT val);
108
111 bool operator<(const Tmat5<DT> &) const { return false; }
112
114 const Tmat5<DT>& operator=(const Tmat5<DT> &m);
115
117 const Tmat5<DT>& operator+=(const Tmat5<DT> &m);
118
120 const Tmat5<DT>& operator-=(const Tmat5<DT> &m);
121
123 const Tmat5<DT>& operator*=(const DT d);
124
127 const Tmat5<DT>& operator/=(const DT d);
128
129 //-------------------------------------------------
130 // Special functions
131 //-------------------------------------------------
133 DT determinantLower4(const int col1, const int col2, const int col3, const int col4) const;
134
136 DT det() const;
137
145 Tmat5<DT> inverse(bool* isInvertible=nullptr) const;
146
148 Tmat5 transpose() const;
149
151 static Tmat5 getIdentity();
152
154 const Tmat5<DT> & apply(MLDblFuncPtr fct);
155
156}; // end of class *Tmat5*
157
158
159
160
161//---------------------------------------------------------------------
162// Constructors
163//---------------------------------------------------------------------
165template <class DT>
166inline Tmat5<DT>::Tmat5()
167{
168 this->v[0] = this->v[1] = this->v[2] = this->v[3] = this->v[4] = Tvec5<DT>(0);
169}
170
172template <class DT>
173inline Tmat5<DT>::Tmat5(const DT diagValue)
174{
175 this->v[0][0] = this->v[1][1] = this->v[2][2] = this->v[3][3] = this->v[4][4] = diagValue;
176 this->v[1][0] = this->v[2][0] = this->v[3][0] = this->v[4][0] = this->v[2][1] = this->v[3][1] = this->v[4][1] = this->v[3][2] = this->v[4][2] = this->v[4][3] = 0;
177 this->v[0][1] = this->v[0][2] = this->v[0][3] = this->v[0][4] = this->v[1][2] = this->v[1][3] = this->v[1][4] = this->v[2][3] = this->v[2][4] = this->v[3][4] = 0;
178}
179
180
182template <class DT>
183inline Tmat5<DT>::Tmat5(const Tvec5<DT>& row0, const Tvec5<DT>& row1, const Tvec5<DT>& row2,
184 const Tvec5<DT>& row3, const Tvec5<DT>& row4)
185{
186 this->v[0] = row0;
187 this->v[1] = row1;
188 this->v[2] = row2;
189 this->v[3] = row3;
190 this->v[4] = row4;
191}
192
194template <class DT>
195inline Tmat5<DT>::Tmat5(const Tmat5<DT> &mat)
196{
197 this->v[0] = mat.v[0];
198 this->v[1] = mat.v[1];
199 this->v[2] = mat.v[2];
200 this->v[3] = mat.v[3];
201 this->v[4] = mat.v[4];
202}
203
205template <class DT>
206inline Tmat5<DT>::Tmat5(const float mat[25])
207{
208 setValues(mat);
209}
210
212template <class DT>
213inline Tmat5<DT>::Tmat5(const double mat[25])
214{
215 setValues(mat);
216}
217
219template <class DT>
220inline Tmat5<DT> Tmat5<DT>::getMat(const double val)
221{
222 return Tmat5<DT>(val, val, val, val, val,
223 val, val, val, val, val,
224 val, val, val, val, val,
225 val, val, val, val, val,
226 val, val, val, val, val);
227}
228
230template <class DT>
231inline void Tmat5<DT>::set(const DT val)
232{
233 this->v[0] = this->v[1] = this->v[2] = this->v[3] = this->v[4] = Tvec5<DT>(val);
234}
235
237template <class DT>
238inline const Tmat5<DT> & Tmat5<DT>::operator=(const Tmat5<DT> &m)
239{
240 if (&m != this){
241 this->v[0] = m.v[0];
242 this->v[1] = m.v[1];
243 this->v[2] = m.v[2];
244 this->v[3] = m.v[3];
245 this->v[4] = m.v[4];
246 }
247
248 return *this;
249}
250
252template <class DT>
253inline const Tmat5<DT> & Tmat5<DT>::operator+=(const Tmat5<DT> &m)
254{
255 this->v[0] += m.v[0];
256 this->v[1] += m.v[1];
257 this->v[2] += m.v[2];
258 this->v[3] += m.v[3];
259 this->v[4] += m.v[4];
260
261 return *this;
262}
263
265template <class DT>
266inline const Tmat5<DT> & Tmat5<DT>::operator-=(const Tmat5<DT> &m)
267{
268 this->v[0] -= m.v[0];
269 this->v[1] -= m.v[1];
270 this->v[2] -= m.v[2];
271 this->v[3] -= m.v[3];
272 this->v[4] -= m.v[4];
273
274 return *this;
275}
276
278template <class DT>
279inline const Tmat5<DT> & Tmat5<DT>::operator*=(const DT d)
280{
281 this->v[0] *= d;
282 this->v[1] *= d;
283 this->v[2] *= d;
284 this->v[3] *= d;
285 this->v[4] *= d;
286
287 return *this;
288}
289
291template <class DT>
292inline const Tmat5<DT> & Tmat5<DT>::operator/=(const DT d)
293{
294 ML_CHECK_FLOAT_THROW(d);
295 this->v[0] /= d;
296 this->v[1] /= d;
297 this->v[2] /= d;
298 this->v[3] /= d;
299 this->v[4] /= d;
300 return *this;
301}
302
303
304//--------------------------------------------------------------------
307//--------------------------------------------------------------------
309template <class DT>
310inline Tmat5<DT> operator-(const Tmat5<DT> &a)
311{
312 return Tmat5<DT>(a) *= static_cast<DT>(-1.0);
313}
314
316template <class DT>
317inline Tmat5<DT> operator+(const Tmat5<DT> &a, const Tmat5<DT> &b)
318{
319 return Tmat5<DT>(a) += b;
320}
321
323template <class DT>
324inline Tmat5<DT> operator-(const Tmat5<DT> &a, const Tmat5<DT> &b)
325{
326 return Tmat5<DT>(a) -= b;
327}
328
330template <class DT>
331inline Tmat5<DT> operator*(const Tmat5<DT> &a, const DT d)
332{
333 return Tmat5<DT>(a) *= d;
334}
335
337template <class DT>
338inline Tmat5<DT> operator*(const DT d, const Tmat5<DT> &a)
339{
340 return Tmat5<DT>(a) *= d;
341}
342
345template <class DT>
346inline Tmat5<DT> operator/(const Tmat5<DT> &a, const DT d)
347{
348 Tmat5<DT> divided(a);
349 ML_CHECK_FLOAT_THROW(d);
350 divided /= d;
351 return divided;
352}
354
355//-------------------------------------------------------------------
356//
357// Tmat5 member functions
358//
359//-------------------------------------------------------------------
360
361//-------------------------------------------------------------------
364//-------------------------------------------------------------------
365template <class DT>
366Tmat5<DT>::Tmat5(const double in00, const double in01, const double in02, const double in03, const double in04,
367 const double in10, const double in11, const double in12, const double in13, const double in14,
368 const double in20, const double in21, const double in22, const double in23, const double in24,
369 const double in30, const double in31, const double in32, const double in33, const double in34,
370 const double in40, const double in41, const double in42, const double in43, const double in44)
371{
372 this->v[0][0]=static_cast<DT>(in00); this->v[0][1]=static_cast<DT>(in01); this->v[0][2]=static_cast<DT>(in02); this->v[0][3]=static_cast<DT>(in03); this->v[0][4]=static_cast<DT>(in04);
373 this->v[1][0]=static_cast<DT>(in10); this->v[1][1]=static_cast<DT>(in11); this->v[1][2]=static_cast<DT>(in12); this->v[1][3]=static_cast<DT>(in13); this->v[1][4]=static_cast<DT>(in14);
374 this->v[2][0]=static_cast<DT>(in20); this->v[2][1]=static_cast<DT>(in21); this->v[2][2]=static_cast<DT>(in22); this->v[2][3]=static_cast<DT>(in23); this->v[2][4]=static_cast<DT>(in24);
375 this->v[3][0]=static_cast<DT>(in30); this->v[3][1]=static_cast<DT>(in31); this->v[3][2]=static_cast<DT>(in32); this->v[3][3]=static_cast<DT>(in33); this->v[3][4]=static_cast<DT>(in34);
376 this->v[4][0]=static_cast<DT>(in40); this->v[4][1]=static_cast<DT>(in41); this->v[4][2]=static_cast<DT>(in42); this->v[4][3]=static_cast<DT>(in43); this->v[4][4]=static_cast<DT>(in44);
377}
378
379
380//--------------------------------------------------------------------
383//--------------------------------------------------------------------
384template <class DT>
385void Tmat5<DT>::setValues(const float m[25])
386{
387 this->v[0][0] = static_cast<DT>(m[ 0]);
388 this->v[0][1] = static_cast<DT>(m[ 1]);
389 this->v[0][2] = static_cast<DT>(m[ 2]);
390 this->v[0][3] = static_cast<DT>(m[ 3]);
391 this->v[0][4] = static_cast<DT>(m[ 4]);
392
393 this->v[1][0] = static_cast<DT>(m[ 5]);
394 this->v[1][1] = static_cast<DT>(m[ 6]);
395 this->v[1][2] = static_cast<DT>(m[ 7]);
396 this->v[1][3] = static_cast<DT>(m[ 8]);
397 this->v[1][4] = static_cast<DT>(m[ 9]);
398
399 this->v[2][0] = static_cast<DT>(m[10]);
400 this->v[2][1] = static_cast<DT>(m[11]);
401 this->v[2][2] = static_cast<DT>(m[12]);
402 this->v[2][3] = static_cast<DT>(m[13]);
403 this->v[2][4] = static_cast<DT>(m[14]);
404
405 this->v[3][0] = static_cast<DT>(m[15]);
406 this->v[3][1] = static_cast<DT>(m[16]);
407 this->v[3][2] = static_cast<DT>(m[17]);
408 this->v[3][3] = static_cast<DT>(m[18]);
409 this->v[3][4] = static_cast<DT>(m[19]);
410
411 this->v[4][0] = static_cast<DT>(m[20]);
412 this->v[4][1] = static_cast<DT>(m[21]);
413 this->v[4][2] = static_cast<DT>(m[22]);
414 this->v[4][3] = static_cast<DT>(m[23]);
415 this->v[4][4] = static_cast<DT>(m[24]);
416}
417
418//--------------------------------------------------------------------
423//--------------------------------------------------------------------
424template <class DT>
425void Tmat5<DT>::getValues(float m[25]) const
426{
427 m[ 0] = static_cast<float>(this->v[0][0]);
428 m[ 1] = static_cast<float>(this->v[0][1]);
429 m[ 2] = static_cast<float>(this->v[0][2]);
430 m[ 3] = static_cast<float>(this->v[0][3]);
431 m[ 4] = static_cast<float>(this->v[0][4]);
432
433 m[ 5] = static_cast<float>(this->v[1][0]);
434 m[ 6] = static_cast<float>(this->v[1][1]);
435 m[ 7] = static_cast<float>(this->v[1][2]);
436 m[ 8] = static_cast<float>(this->v[1][3]);
437 m[ 9] = static_cast<float>(this->v[1][4]);
438
439 m[10] = static_cast<float>(this->v[2][0]);
440 m[11] = static_cast<float>(this->v[2][1]);
441 m[12] = static_cast<float>(this->v[2][2]);
442 m[13] = static_cast<float>(this->v[2][3]);
443 m[14] = static_cast<float>(this->v[2][4]);
444
445 m[15] = static_cast<float>(this->v[3][0]);
446 m[16] = static_cast<float>(this->v[3][1]);
447 m[17] = static_cast<float>(this->v[3][2]);
448 m[18] = static_cast<float>(this->v[3][3]);
449 m[19] = static_cast<float>(this->v[3][4]);
450
451 m[20] = static_cast<float>(this->v[4][0]);
452 m[21] = static_cast<float>(this->v[4][1]);
453 m[22] = static_cast<float>(this->v[4][2]);
454 m[23] = static_cast<float>(this->v[4][3]);
455 m[24] = static_cast<float>(this->v[4][4]);
456}
457
458//--------------------------------------------------------------------
461//--------------------------------------------------------------------
462template <class DT>
463void Tmat5<DT>::setValues(const double m[25])
464{
465 this->v[0][0] = static_cast<DT>(m[ 0]);
466 this->v[0][1] = static_cast<DT>(m[ 1]);
467 this->v[0][2] = static_cast<DT>(m[ 2]);
468 this->v[0][3] = static_cast<DT>(m[ 3]);
469 this->v[0][4] = static_cast<DT>(m[ 4]);
470
471 this->v[1][0] = static_cast<DT>(m[ 5]);
472 this->v[1][1] = static_cast<DT>(m[ 6]);
473 this->v[1][2] = static_cast<DT>(m[ 7]);
474 this->v[1][3] = static_cast<DT>(m[ 8]);
475 this->v[1][4] = static_cast<DT>(m[ 9]);
476
477 this->v[2][0] = static_cast<DT>(m[10]);
478 this->v[2][1] = static_cast<DT>(m[11]);
479 this->v[2][2] = static_cast<DT>(m[12]);
480 this->v[2][3] = static_cast<DT>(m[13]);
481 this->v[2][4] = static_cast<DT>(m[14]);
482
483 this->v[3][0] = static_cast<DT>(m[15]);
484 this->v[3][1] = static_cast<DT>(m[16]);
485 this->v[3][2] = static_cast<DT>(m[17]);
486 this->v[3][3] = static_cast<DT>(m[18]);
487 this->v[3][4] = static_cast<DT>(m[19]);
488
489 this->v[4][0] = static_cast<DT>(m[20]);
490 this->v[4][1] = static_cast<DT>(m[21]);
491 this->v[4][2] = static_cast<DT>(m[22]);
492 this->v[4][3] = static_cast<DT>(m[23]);
493 this->v[4][4] = static_cast<DT>(m[24]);
494}
495
496//--------------------------------------------------------------------
499//--------------------------------------------------------------------
500template <class DT>
501void Tmat5<DT>::getValues(double m[25]) const
502{
503 m[ 0] = static_cast<double>(this->v[0][0]);
504 m[ 1] = static_cast<double>(this->v[0][1]);
505 m[ 2] = static_cast<double>(this->v[0][2]);
506 m[ 3] = static_cast<double>(this->v[0][3]);
507 m[ 4] = static_cast<double>(this->v[0][4]);
508
509 m[ 5] = static_cast<double>(this->v[1][0]);
510 m[ 6] = static_cast<double>(this->v[1][1]);
511 m[ 7] = static_cast<double>(this->v[1][2]);
512 m[ 8] = static_cast<double>(this->v[1][3]);
513 m[ 9] = static_cast<double>(this->v[1][4]);
514
515 m[10] = static_cast<double>(this->v[2][0]);
516 m[11] = static_cast<double>(this->v[2][1]);
517 m[12] = static_cast<double>(this->v[2][2]);
518 m[13] = static_cast<double>(this->v[2][3]);
519 m[14] = static_cast<double>(this->v[2][4]);
520
521 m[15] = static_cast<double>(this->v[3][0]);
522 m[16] = static_cast<double>(this->v[3][1]);
523 m[17] = static_cast<double>(this->v[3][2]);
524 m[18] = static_cast<double>(this->v[3][3]);
525 m[19] = static_cast<double>(this->v[3][4]);
526
527 m[20] = static_cast<double>(this->v[4][0]);
528 m[21] = static_cast<double>(this->v[4][1]);
529 m[22] = static_cast<double>(this->v[4][2]);
530 m[23] = static_cast<double>(this->v[4][3]);
531 m[24] = static_cast<double>(this->v[4][4]);
532}
533
534
535//-------------------------------------------------------------------
537//-------------------------------------------------------------------
538template <class DT>
539void Tmat5<DT>::setScaleMatrix(const DT scale)
540{
541 this->v[0][0] = scale; this->v[0][1] = 0; this->v[0][2] = 0; this->v[0][3] = 0; this->v[0][4] = 0;
542 this->v[1][0] = 0; this->v[1][1] = scale; this->v[1][2] = 0; this->v[1][3] = 0; this->v[1][4] = 0;
543 this->v[2][0] = 0; this->v[2][1] = 0; this->v[2][2] = scale; this->v[2][3] = 0; this->v[2][4] = 0;
544 this->v[3][0] = 0; this->v[3][1] = 0; this->v[3][2] = 0; this->v[3][3] = scale; this->v[3][4] = 0;
545 this->v[4][0] = 0; this->v[4][1] = 0; this->v[4][2] = 0; this->v[4][3] = 0; this->v[4][4] = scale;
546}
547
548
549
550
551//-------------------------------------------------------------------
554//-------------------------------------------------------------------
555
556//--------------------------------------------------------------------
558//--------------------------------------------------------------------
559template <class DT>
560inline DT Tmat5<DT>::determinantLower4(const int col1, const int col2, const int col3, const int col4) const
561{
562 /* Determinant of 4x4 matrix with given entries */
563 return Tmat4<DT>(this->v[1][col1], this->v[1][col2], this->v[1][col3], this->v[1][col4],
564 this->v[2][col1], this->v[2][col2], this->v[2][col3], this->v[2][col4],
565 this->v[3][col1], this->v[3][col2], this->v[3][col3], this->v[3][col4],
566 this->v[4][col1], this->v[4][col2], this->v[4][col3], this->v[4][col4]).det();
567}
568
569//--------------------------------------------------------------------
571//--------------------------------------------------------------------
572template <class DT>
573DT Tmat5<DT>::det() const
574{
575 return ( this->v[0][0] * determinantLower4(1, 2, 3, 4)
576 - this->v[0][1] * determinantLower4(0, 2, 3, 4)
577 + this->v[0][2] * determinantLower4(0, 1, 3, 4)
578 - this->v[0][3] * determinantLower4(0, 1, 2, 4)
579 + this->v[0][4] * determinantLower4(0, 1, 2, 3));
580}
581
582//--------------------------------------------------------------------
590//--------------------------------------------------------------------
591template <class DT>
592Tmat5<DT> Tmat5<DT>::inverse(bool* isInvertible) const
593{
594 // Epsilon for comparison with 0 in inversion process.
595 static const DT Epsilon = static_cast<DT>(10e-13);
596
597 // Use helper function from tools to invert the matrix.
598 return MLInverseMatHelper(*this,
599 isInvertible,
600 Epsilon,
601 "Tmat5<DT> Tmat5<DT>::inverse(bool* isInvertible) const, matrix not invertable",
602 getIdentity(),
603 5);
604}
605
606
607//-------------------------------------------------------------------
609//-------------------------------------------------------------------
610template <class DT>
611inline Tmat5<DT> Tmat5<DT>::transpose() const
612{
613 return Tmat5<DT>(Tvec5<DT>(this->v[0][0], this->v[1][0], this->v[2][0], this->v[3][0], this->v[4][0]),
614 Tvec5<DT>(this->v[0][1], this->v[1][1], this->v[2][1], this->v[3][1], this->v[4][1]),
615 Tvec5<DT>(this->v[0][2], this->v[1][2], this->v[2][2], this->v[3][2], this->v[4][2]),
616 Tvec5<DT>(this->v[0][3], this->v[1][3], this->v[2][3], this->v[3][3], this->v[4][3]),
617 Tvec5<DT>(this->v[0][4], this->v[1][4], this->v[2][4], this->v[3][4], this->v[4][4]));
618}
619
620//-------------------------------------------------------------------
622//-------------------------------------------------------------------
623template <class DT>
624inline Tmat5<DT> Tmat5<DT>::getIdentity()
625{
626 return Tmat5<DT>(Tvec5<DT>(1,0,0,0,0),
627 Tvec5<DT>(0,1,0,0,0),
628 Tvec5<DT>(0,0,1,0,0),
629 Tvec5<DT>(0,0,0,1,0),
630 Tvec5<DT>(0,0,0,0,1));
631}
632
633//-------------------------------------------------------------------
635//-------------------------------------------------------------------
636template <class DT>
637const Tmat5<DT> & Tmat5<DT>::apply(MLDblFuncPtr fct)
638{
639 this->v[0].apply(fct);
640 this->v[1].apply(fct);
641 this->v[2].apply(fct);
642 this->v[3].apply(fct);
643 this->v[4].apply(fct);
644 return *this;
645}
646
647
649#define _ML_MAT5_RC(i, j) a[i][0]*b[0][j] + a[i][1]*b[1][j] + a[i][2]*b[2][j] + \
650a[i][3]*b[3][j] + a[i][4]*b[4][j]
651//-------------------------------------------------------------------
653//-------------------------------------------------------------------
654template <class DT>
655Tmat5<DT> operator*(const Tmat5<DT> &a, const Tmat5<DT> &b)
656{
657 return Tmat5<DT>(Tvec5<DT>(_ML_MAT5_RC(0,0), _ML_MAT5_RC(0,1), _ML_MAT5_RC(0,2), _ML_MAT5_RC(0,3), _ML_MAT5_RC(0,4)),
658 Tvec5<DT>(_ML_MAT5_RC(1,0), _ML_MAT5_RC(1,1), _ML_MAT5_RC(1,2), _ML_MAT5_RC(1,3), _ML_MAT5_RC(1,4)),
659 Tvec5<DT>(_ML_MAT5_RC(2,0), _ML_MAT5_RC(2,1), _ML_MAT5_RC(2,2), _ML_MAT5_RC(2,3), _ML_MAT5_RC(2,4)),
660 Tvec5<DT>(_ML_MAT5_RC(3,0), _ML_MAT5_RC(3,1), _ML_MAT5_RC(3,2), _ML_MAT5_RC(3,3), _ML_MAT5_RC(3,4)),
661 Tvec5<DT>(_ML_MAT5_RC(4,0), _ML_MAT5_RC(4,1), _ML_MAT5_RC(4,2), _ML_MAT5_RC(4,3), _ML_MAT5_RC(4,4)));
662}
663#undef _ML_MAT5_RC
664
665
666// Note: Multiplications with Vector5 are implemented with/in class Tvec5.
667
668
669//-------------------------------------------------------------------
671//-------------------------------------------------------------------
672template <class DT>
673inline bool operator==(const Tmat5<DT> &a, const Tmat5<DT> &b)
674{
675 return (a[0] == b[0]) &&
676 (a[1] == b[1]) &&
677 (a[2] == b[2]) &&
678 (a[3] == b[3]) &&
679 (a[4] == b[4]);
680}
681
682//-------------------------------------------------------------------
684//-------------------------------------------------------------------
685template <class DT>
686inline bool operator!=(const Tmat5<DT> &a, const Tmat5<DT> &b)
687{
688 return !(a == b);
689}
691
692
693//-----------------------------------------------------------------------------------
696//-----------------------------------------------------------------------------------
697
699typedef Tmat5<MLfloat> Matrix5f;
701typedef Tmat5<MLdouble> Matrix5d;
703typedef Tmat5<MLldouble> Matrix5ld;
705typedef Tmat5<MLdouble> Matrix5;
707
708
709ML_LA_END_NAMESPACE
710
711namespace std
712{
713 //-------------------------------------------------------------------
715 //-------------------------------------------------------------------
716 template <class DT>
717 inline std::ostream& operator<<(std::ostream& os, const ML_LA_NAMESPACE::Tmat5<DT> & m)
718 {
719 return os << m[0] << '\n' << m[1] << '\n' << m[2] << '\n' << m[3] << '\n' << m[4];
720 }
721
722 //-------------------------------------------------------------------
724 //-------------------------------------------------------------------
725 template <class DT>
726 inline std::istream& operator>>(std::istream& is, ML_LA_NAMESPACE::Tmat5<DT> & m)
727 {
728 ML_LA_NAMESPACE::Tmat5<DT> m_tmp;
729
730 is >> m_tmp[0] >> m_tmp[1] >> m_tmp[2] >> m_tmp[3] >> m_tmp[4];
731 if (is){ m = m_tmp; }
732 return is;
733 }
734}
735
736
737#endif // __mlMatrix5_H
738
739
ml::FloatingPointMatrix
Base class of all matrix classes that holds the data buffer and provides some general access methods.
Definition mlFloatingPointMatrix.h:35
ml::FloatingPointMatrix::v
VectorT v[size]
The rows constituting the matrix.
Definition mlFloatingPointMatrix.h:93
ml::Tmat4
A 4x4 matrix class consisting of four row vectors.
Definition mlMatrix4.h:36
ml::Tmat4::det
DT det() const
Returns the determinant of this.
Definition mlMatrix4.h:560
ml::Tmat5
A 5x5 matrix class of five row vectors.
Definition mlMatrix5.h:49
ml::Tmat5::transpose
Tmat5 transpose() const
Returns the transposed of this matrix.
Definition mlMatrix5.h:611
ml::Tmat5::operator+=
const Tmat5< DT > & operator+=(const Tmat5< DT > &m)
Adds component-wise by a Tmat5.
Definition mlMatrix5.h:253
ml::Tmat5::operator/=
const Tmat5< DT > & operator/=(const DT d)
Divides by a scalar constant d.
Definition mlMatrix5.h:292
ml::Tmat5::set
void set(const DT val)
Sets all values to val.
Definition mlMatrix5.h:231
ml::Tmat5::getMat
static Tmat5< DT > getMat(const double val)
Returns a matrix filled with values val.
Definition mlMatrix5.h:220
ml::Tmat5::getIdentity
static Tmat5 getIdentity()
Returns the identity matrix.
Definition mlMatrix5.h:624
ml::Tmat5::operator<
bool operator<(const Tmat5< DT > &) const
Dummy 'lesser than operator' which always returns false.
Definition mlMatrix5.h:111
ml::Tmat5::Tmat5
Tmat5()
Builds a 5x5 matrix from 25 zero elements.
Definition mlMatrix5.h:166
ml::Tmat5::ComponentType
DT ComponentType
A typedef to 'export' the type of components.
Definition mlMatrix5.h:53
ml::Tmat5::setScaleMatrix
void setScaleMatrix(const DT scale)
Sets the diagonal matrix with scale on the diagonal.
Definition mlMatrix5.h:539
ml::Tmat5::det
DT det() const
Determinant.
Definition mlMatrix5.h:573
ml::Tmat5::Tmat5
Tmat5(const float mat[25])
Constructor from 25 floats given as array mat, row by row.
Definition mlMatrix5.h:206
ml::Tmat5::Tmat5
Tmat5(const Tvec5< DT > &row0, const Tvec5< DT > &row1, const Tvec5< DT > &row2, const Tvec5< DT > &row3, const Tvec5< DT > &row4)
Builds the matrix of the five row vectors row0, ..., row5.
Definition mlMatrix5.h:183
ml::Tmat5::operator=
const Tmat5< DT > & operator=(const Tmat5< DT > &m)
Assigns from a Tmat5.
Definition mlMatrix5.h:238
ml::Tmat5::setValues
void setValues(const float m[25])
Copies the contents from float array m into *this.
Definition mlMatrix5.h:385
ml::Tmat5::operator*=
const Tmat5< DT > & operator*=(const DT d)
Multiplies by a scalar constant d.
Definition mlMatrix5.h:279
ml::Tmat5::inverse
Tmat5< DT > inverse(bool *isInvertible=nullptr) const
Returns the inverse Gauss-Jordan elimination with partial pivoting.
Definition mlMatrix5.h:592
ml::Tmat5::apply
const Tmat5< DT > & apply(MLDblFuncPtr fct)
Applies the function fct to each component.
Definition mlMatrix5.h:637
ml::Tmat5::Tmat5
Tmat5(const double in00, const double in01, const double in02, const double in03, const double in04, const double in10, const double in11, const double in12, const double in13, const double in14, const double in20, const double in21, const double in22, const double in23, const double in24, const double in30, const double in31, const double in32, const double in33, const double in34, const double in40, const double in41, const double in42, const double in43, const double in44)
Initializes all matrix elements explicitly with scalars, filling it row by row.
Definition mlMatrix5.h:366
ml::Tmat5::Tmat5
Tmat5(const Tmat5< DT > &mat)
Copy constructor from the Tmat5 mat.
Definition mlMatrix5.h:195
ml::Tmat5::getValues
void getValues(double m[25]) const
Copies the contents of *this into double array m.
Definition mlMatrix5.h:501
ml::Tmat5::getValues
void getValues(float m[25]) const
Copies the contents of *this into float array m.
Definition mlMatrix5.h:425
ml::Tmat5::operator-=
const Tmat5< DT > & operator-=(const Tmat5< DT > &m)
Subtracts component-wise by a Tmat5.
Definition mlMatrix5.h:266
ml::Tmat5::Tmat5
Tmat5(const DT diagValue)
Builds a matrix that has the argument diagValue as the diagonal values, zero otherwise.
Definition mlMatrix5.h:173
ml::Tmat5::Tmat5
Tmat5(const double mat[25])
Constructor from 25 doubles given as array mat, row by row.
Definition mlMatrix5.h:213
ml::Tmat5::setValues
void setValues(const double m[25])
Copies the contents from double array m into *this.
Definition mlMatrix5.h:463
ml::Tmat5::determinantLower4
DT determinantLower4(const int col1, const int col2, const int col3, const int col4) const
Determines the (sub)determinant of columns given by col1, col2, col3, and col4.
Definition mlMatrix5.h:560
ml::Tvec5
Forward declarations to resolve header file dependencies.
Definition mlVector5.h:48
ML_CHECK_FLOAT_THROW
#define ML_CHECK_FLOAT_THROW(x)
Definition mlErrorMacros.h:106
_ML_MAT5_RC
#define _ML_MAT5_RC(i, j)
Internal helper macro to multiply two matrices, do not use.
Definition mlMatrix5.h:649
MLDblFuncPtr
double(* MLDblFuncPtr)(double)
A function pointer type to a function that returns a double and takes a double as argument.
Definition mlTypeDefs.h:1166
ml::operator/
FloatingPointVector< T, size, DataContainer > operator/(FloatingPointVector< T, size, DataContainer > lhs, MLdouble rhs)
Component-wise division of lhs by specialized rhs of type MLdouble.
Definition mlFloatingPointVector.h:413
ml::operator==
bool operator==(const Tmat2< DT > &a, const Tmat2< DT > &b)
a == b ? Returns true if yes.
Definition mlMatrix2.h:425
ml::operator*
T operator*(const FloatingPointVector< T, size, DataContainer > &a, const FloatingPointVector< T, size, DataContainer > &b)
Dot product, returns a.dot(b).
Definition mlFloatingPointVector.h:383
ml::operator!=
bool operator!=(const Tmat2< DT > &a, const Tmat2< DT > &b)
a != b ? Returns true if yes.
Definition mlMatrix2.h:433
ml::operator-
FloatingPointVector< T, size, DataContainer > operator-(FloatingPointVector< T, size, DataContainer > lhs, const FloatingPointVector< T, size, DataContainer > &rhs)
Return value is the component-wise subtraction of rhs from lhs.
Definition mlFloatingPointVector.h:349
ml::MLInverseMatHelper
BASE_TYPE MLInverseMatHelper(const BASE_TYPE &origMat, bool *isInvertible, const typename BASE_TYPE::ComponentType, const char *const ZeroDetErrString, const BASE_TYPE &Identity, const size_t Dim)
Computes an N dimensional inverse from given default parameters.
Definition mlLinearAlgebraTools.h:60
std
STL namespace.
std::operator<<
MLEXPORT std::ostream & operator<<(std::ostream &s, const ml::Field &v)
Overloads the operator '<<' for stream output of Field objects.
std::operator>>
istream & operator>>(istream &is, ml::FloatingPointVector< T, size, DataContainer > &v)
Reads a vector from std::istream.
Definition mlFloatingPointVector.h:563