Merge "Remove tests affected by NV/OES_viewport_array extension" into nougat-cts...
[platform/upstream/VK-GL-CTS.git] / framework / common / tcuMatrix.hpp
1 #ifndef _TCUMATRIX_HPP
2 #define _TCUMATRIX_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Tester Core
5  * ----------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Templatized matrix class.
24  *//*--------------------------------------------------------------------*/
25
26 #include "tcuDefs.hpp"
27 #include "tcuVector.hpp"
28 #include "tcuArray.hpp"
29
30 namespace tcu
31 {
32
33 // Templated matrix class.
34 template <typename T, int Rows, int Cols>
35 class Matrix
36 {
37 public:
38         typedef Vector<T, Rows>                 Element;
39         typedef T                                               Scalar;
40
41         enum
42         {
43                 SIZE = Cols,
44                 ROWS = Rows,
45                 COLS = Cols,
46         };
47
48                                                                         Matrix                          (void);
49         explicit                                                Matrix                          (const T& src);
50         explicit                                                Matrix                          (const T src[Rows*Cols]);
51                                                                         Matrix                          (const Vector<T, Rows>& src);
52                                                                         Matrix                          (const Matrix<T, Rows, Cols>& src);
53                                                                         ~Matrix                         (void);
54
55         Matrix<T, Rows, Cols>&                  operator=                       (const Matrix<T, Rows, Cols>& src);
56         Matrix<T, Rows, Cols>&                  operator*=                      (const Matrix<T, Rows, Cols>& src);
57
58         void                                                    setRow                          (int rowNdx, const Vector<T, Cols>& vec);
59         void                                                    setColumn                       (int colNdx, const Vector<T, Rows>& vec);
60
61         Vector<T, Cols>                                 getRow                          (int ndx) const;
62         Vector<T, Rows>&                                getColumn                       (int ndx);
63         const Vector<T, Rows>&                  getColumn                       (int ndx) const;
64
65         Vector<T, Rows>&                                operator[]                      (int ndx)                                       { return getColumn(ndx);        }
66         const Vector<T, Rows>&                  operator[]                      (int ndx) const                         { return getColumn(ndx);        }
67
68         inline const T&                                 operator()                      (int row, int col) const        { return m_data[col][row];      }
69         inline T&                                               operator()                      (int row, int col)                      { return m_data[col][row];      }
70
71         Array<T, Rows*Cols>                             getRowMajorData         (void) const;
72         Array<T, Rows*Cols>                             getColumnMajorData      (void) const;
73
74 private:
75         Vector<Vector<T, Rows>, Cols>   m_data;
76 } DE_WARN_UNUSED_TYPE;
77
78 // Operators.
79
80 // Mat * Mat.
81 template <typename T, int Rows0, int Cols0, int Rows1, int Cols1>
82 Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b);
83
84 // Mat * Vec (column vector).
85 template <typename T, int Rows, int Cols>
86 Vector<T, Rows> operator* (const Matrix<T, Rows, Cols>& mtx, const Vector<T, Cols>& vec);
87
88 // Vec * Mat (row vector).
89 template <typename T, int Rows, int Cols>
90 Vector<T, Cols> operator* (const Vector<T, Rows>& vec, const Matrix<T, Rows, Cols>& mtx);
91
92 // Further operations
93
94 template <typename T, int Size>
95 struct SquareMatrixOps
96 {
97         static T                                                doDeterminant   (const Matrix<T, Size, Size>& mat);
98         static Matrix<T, Size, Size>    doInverse               (const Matrix<T, Size, Size>& mat);
99 };
100
101 template <typename T>
102 struct SquareMatrixOps<T, 2>
103 {
104         static T                                                doDeterminant   (const Matrix<T, 2, 2>& mat);
105         static Matrix<T, 2, 2>                  doInverse               (const Matrix<T, 2, 2>& mat);
106 };
107
108 template <typename T>
109 struct SquareMatrixOps<T, 3>
110 {
111         static T                                                doDeterminant   (const Matrix<T, 3, 3>& mat);
112         static Matrix<T, 3, 3>                  doInverse               (const Matrix<T, 3, 3>& mat);
113 };
114
115 template <typename T>
116 struct SquareMatrixOps<T, 4>
117 {
118         static T                                                doDeterminant   (const Matrix<T, 4, 4>& mat);
119         static Matrix<T, 4, 4>                  doInverse               (const Matrix<T, 4, 4>& mat);
120 };
121
122 namespace matrix
123 {
124
125 template <typename T, int Size>
126 T determinant (const Matrix<T, Size, Size>& mat)
127 {
128         return SquareMatrixOps<T, Size>::doDeterminant(mat);
129 }
130
131 template <typename T, int Size>
132 Matrix<T, Size, Size> inverse (const Matrix<T, Size, Size>& mat)
133 {
134         return SquareMatrixOps<T, Size>::doInverse(mat);
135 }
136
137 } // matrix
138
139 // Template implementations.
140
141 template <typename T>
142 T SquareMatrixOps<T, 2>::doDeterminant (const Matrix<T, 2, 2>& mat)
143 {
144         return mat(0,0) * mat(1,1) - mat(1,0) * mat(0,1);
145 }
146
147 template <typename T>
148 T SquareMatrixOps<T, 3>::doDeterminant (const Matrix<T, 3, 3>& mat)
149 {
150         return  + mat(0,0) * mat(1,1) * mat(2,2)
151                         + mat(0,1) * mat(1,2) * mat(2,0)
152                         + mat(0,2) * mat(1,0) * mat(2,1)
153                         - mat(0,0) * mat(1,2) * mat(2,1)
154                         - mat(0,1) * mat(1,0) * mat(2,2)
155                         - mat(0,2) * mat(1,1) * mat(2,0);
156 }
157
158 template <typename T>
159 T SquareMatrixOps<T, 4>::doDeterminant (const Matrix<T, 4, 4>& mat)
160 {
161         using matrix::determinant;
162
163         const T minorMatrices[4][3*3] =
164         {
165                 {
166                         mat(1,1),       mat(2,1),       mat(3,1),
167                         mat(1,2),       mat(2,2),       mat(3,2),
168                         mat(1,3),       mat(2,3),       mat(3,3),
169                 },
170                 {
171                         mat(1,0),       mat(2,0),       mat(3,0),
172                         mat(1,2),       mat(2,2),       mat(3,2),
173                         mat(1,3),       mat(2,3),       mat(3,3),
174                 },
175                 {
176                         mat(1,0),       mat(2,0),       mat(3,0),
177                         mat(1,1),       mat(2,1),       mat(3,1),
178                         mat(1,3),       mat(2,3),       mat(3,3),
179                 },
180                 {
181                         mat(1,0),       mat(2,0),       mat(3,0),
182                         mat(1,1),       mat(2,1),       mat(3,1),
183                         mat(1,2),       mat(2,2),       mat(3,2),
184                 }
185         };
186
187         return  + mat(0,0) * determinant(Matrix<T, 3, 3>(minorMatrices[0]))
188                         - mat(0,1) * determinant(Matrix<T, 3, 3>(minorMatrices[1]))
189                         + mat(0,2) * determinant(Matrix<T, 3, 3>(minorMatrices[2]))
190                         - mat(0,3) * determinant(Matrix<T, 3, 3>(minorMatrices[3]));
191 }
192
193 template <typename T>
194 Matrix<T, 2, 2> SquareMatrixOps<T, 2>::doInverse (const Matrix<T, 2, 2>& mat)
195 {
196         using matrix::determinant;
197
198         const T                 det             = determinant(mat);
199         Matrix<T, 2, 2> retVal;
200
201         retVal(0, 0) =  mat(1, 1) / det;
202         retVal(0, 1) = -mat(0, 1) / det;
203         retVal(1, 0) = -mat(1, 0) / det;
204         retVal(1, 1) =  mat(0, 0) / det;
205
206         return retVal;
207 }
208
209 template <typename T>
210 Matrix<T, 3, 3> SquareMatrixOps<T, 3>::doInverse (const Matrix<T, 3, 3>& mat)
211 {
212         // Blockwise inversion
213         using matrix::inverse;
214
215         const T areaA[2*2] =
216         {
217                 mat(0,0),       mat(0,1),
218                 mat(1,0),       mat(1,1)
219         };
220         const T areaB[2] =
221         {
222                 mat(0,2),
223                 mat(1,2),
224         };
225         const T areaC[2] =
226         {
227                 mat(2,0),       mat(2,1),
228         };
229         const T areaD[1] =
230         {
231                 mat(2,2)
232         };
233         const T nullField[4] = { T(0.0f) };
234
235         const Matrix<T, 2, 2>   invA = inverse(Matrix<T, 2, 2>(areaA));
236         const Matrix<T, 2, 1>   matB =         Matrix<T, 2, 1>(areaB);
237         const Matrix<T, 1, 2>   matC =         Matrix<T, 1, 2>(areaC);
238         const Matrix<T, 1, 1>   matD =         Matrix<T, 1, 1>(areaD);
239
240         const T                                 schurComplement = T(1.0f) / (matD - matC*invA*matB)(0,0);
241         const Matrix<T, 2, 2>   zeroMat         = Matrix<T, 2, 2>(nullField);
242
243         const Matrix<T, 2, 2>   blockA = invA + invA*matB*schurComplement*matC*invA;
244         const Matrix<T, 2, 1>   blockB = (zeroMat-invA)*matB*schurComplement;
245         const Matrix<T, 1, 2>   blockC = matC*invA*(-schurComplement);
246         const T                                 blockD = schurComplement;
247
248         const T result[3*3] =
249         {
250                 blockA(0,0),    blockA(0,1),    blockB(0,0),
251                 blockA(1,0),    blockA(1,1),    blockB(1,0),
252                 blockC(0,0),    blockC(0,1),    blockD,
253         };
254
255         return Matrix<T, 3, 3>(result);
256 }
257
258 template <typename T>
259 Matrix<T, 4, 4> SquareMatrixOps<T, 4>::doInverse (const Matrix<T, 4, 4>& mat)
260 {
261         // Blockwise inversion
262         using matrix::inverse;
263
264         const T areaA[2*2] =
265         {
266                 mat(0,0),       mat(0,1),
267                 mat(1,0),       mat(1,1)
268         };
269         const T areaB[2*2] =
270         {
271                 mat(0,2),       mat(0,3),
272                 mat(1,2),       mat(1,3)
273         };
274         const T areaC[2*2] =
275         {
276                 mat(2,0),       mat(2,1),
277                 mat(3,0),       mat(3,1)
278         };
279         const T areaD[2*2] =
280         {
281                 mat(2,2),       mat(2,3),
282                 mat(3,2),       mat(3,3)
283         };
284         const T nullField[4] = { T(0.0f) };
285
286         const Matrix<T, 2, 2> invA = inverse(Matrix<T, 2, 2>(areaA));
287         const Matrix<T, 2, 2> matB =         Matrix<T, 2, 2>(areaB);
288         const Matrix<T, 2, 2> matC =         Matrix<T, 2, 2>(areaC);
289         const Matrix<T, 2, 2> matD =         Matrix<T, 2, 2>(areaD);
290
291         const Matrix<T, 2, 2> schurComplement = inverse(matD - matC*invA*matB);
292         const Matrix<T, 2, 2> zeroMat         = Matrix<T, 2, 2>(nullField);
293
294         const Matrix<T, 2, 2> blockA = invA + invA*matB*schurComplement*matC*invA;
295         const Matrix<T, 2, 2> blockB = (zeroMat-invA)*matB*schurComplement;
296         const Matrix<T, 2, 2> blockC = (zeroMat-schurComplement)*matC*invA;
297         const Matrix<T, 2, 2> blockD = schurComplement;
298
299         const T result[4*4] =
300         {
301                 blockA(0,0),    blockA(0,1),    blockB(0,0),    blockB(0,1),
302                 blockA(1,0),    blockA(1,1),    blockB(1,0),    blockB(1,1),
303                 blockC(0,0),    blockC(0,1),    blockD(0,0),    blockD(0,1),
304                 blockC(1,0),    blockC(1,1),    blockD(1,0),    blockD(1,1),
305         };
306
307         return Matrix<T, 4, 4>(result);
308 }
309
310 // Initialize to identity.
311 template <typename T, int Rows, int Cols>
312 Matrix<T, Rows, Cols>::Matrix (void)
313 {
314         for (int row = 0; row < Rows; row++)
315                 for (int col = 0; col < Cols; col++)
316                         (*this)(row, col) = (row == col) ? T(1) : T(0);
317 }
318
319 // Initialize to diagonal matrix.
320 template <typename T, int Rows, int Cols>
321 Matrix<T, Rows, Cols>::Matrix (const T& src)
322 {
323         for (int row = 0; row < Rows; row++)
324                 for (int col = 0; col < Cols; col++)
325                         (*this)(row, col) = (row == col) ? src : T(0);
326 }
327
328 // Initialize from data array.
329 template <typename T, int Rows, int Cols>
330 Matrix<T, Rows, Cols>::Matrix (const T src[Rows*Cols])
331 {
332         for (int row = 0; row < Rows; row++)
333                 for (int col = 0; col < Cols; col++)
334                         (*this)(row, col) = src[row*Cols + col];
335 }
336
337 // Initialize to diagonal matrix.
338 template <typename T, int Rows, int Cols>
339 Matrix<T, Rows, Cols>::Matrix (const Vector<T, Rows>& src)
340 {
341         DE_STATIC_ASSERT(Rows == Cols);
342         for (int row = 0; row < Rows; row++)
343                 for (int col = 0; col < Cols; col++)
344                         (*this)(row, col) = (row == col) ? src.m_data[row] : T(0);
345 }
346
347 // Copy constructor.
348 template <typename T, int Rows, int Cols>
349 Matrix<T, Rows, Cols>::Matrix (const Matrix<T, Rows, Cols>& src)
350 {
351         *this = src;
352 }
353
354 // Destructor.
355 template <typename T, int Rows, int Cols>
356 Matrix<T, Rows, Cols>::~Matrix (void)
357 {
358 }
359
360 // Assignment operator.
361 template <typename T, int Rows, int Cols>
362 Matrix<T, Rows, Cols>& Matrix<T, Rows, Cols>::operator= (const Matrix<T, Rows, Cols>& src)
363 {
364         for (int row = 0; row < Rows; row++)
365                 for (int col = 0; col < Cols; col++)
366                         (*this)(row, col) = src(row, col);
367         return *this;
368 }
369
370 // Multipy and assign op
371 template <typename T, int Rows, int Cols>
372 Matrix<T, Rows, Cols>& Matrix<T, Rows, Cols>::operator*= (const Matrix<T, Rows, Cols>& src)
373 {
374         *this = *this * src;
375         return *this;
376 }
377
378 template <typename T, int Rows, int Cols>
379 void Matrix<T, Rows, Cols>::setRow (int rowNdx, const Vector<T, Cols>& vec)
380 {
381         for (int col = 0; col < Cols; col++)
382                 (*this)(rowNdx, col) = vec.m_data[col];
383 }
384
385 template <typename T, int Rows, int Cols>
386 void Matrix<T, Rows, Cols>::setColumn (int colNdx, const Vector<T, Rows>& vec)
387 {
388         m_data[colNdx] = vec;
389 }
390
391 template <typename T, int Rows, int Cols>
392 Vector<T, Cols> Matrix<T, Rows, Cols>::getRow (int rowNdx) const
393 {
394         Vector<T, Cols> res;
395         for (int col = 0; col < Cols; col++)
396                 res[col] = (*this)(rowNdx, col);
397         return res;
398 }
399
400 template <typename T, int Rows, int Cols>
401 Vector<T, Rows>& Matrix<T, Rows, Cols>::getColumn (int colNdx)
402 {
403         return m_data[colNdx];
404 }
405
406 template <typename T, int Rows, int Cols>
407 const Vector<T, Rows>& Matrix<T, Rows, Cols>::getColumn (int colNdx) const
408 {
409         return m_data[colNdx];
410 }
411
412 template <typename T, int Rows, int Cols>
413 Array<T, Rows*Cols> Matrix<T, Rows, Cols>::getColumnMajorData (void) const
414 {
415         Array<T, Rows*Cols> a;
416         T* dst = a.getPtr();
417         for (int col = 0; col < Cols; col++)
418                 for (int row = 0; row < Rows; row++)
419                         *dst++ = (*this)(row, col);
420         return a;
421 }
422
423 template <typename T, int Rows, int Cols>
424 Array<T, Rows*Cols> Matrix<T, Rows, Cols>::getRowMajorData (void) const
425 {
426         Array<T, Rows*Cols> a;
427         T* dst = a.getPtr();
428         for (int row = 0; row < Rows; row++)
429                 for (int col = 0; col < Cols; col++)
430                         *dst++ = (*this)(row, col);
431         return a;
432 }
433
434 // Multiplication of two matrices.
435 template <typename T, int Rows0, int Cols0, int Rows1, int Cols1>
436 Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
437 {
438         DE_STATIC_ASSERT(Cols0 == Rows1);
439         Matrix<T, Rows0, Cols1> res;
440         for (int row = 0; row < Rows0; row++)
441         {
442                 for (int col = 0; col < Cols1; col++)
443                 {
444                         T v = T(0);
445                         for (int ndx = 0; ndx < Cols0; ndx++)
446                                 v += a(row,ndx) * b(ndx,col);
447                         res(row,col) = v;
448                 }
449         }
450         return res;
451 }
452
453 // Multiply of matrix with column vector.
454 template <typename T, int Rows, int Cols>
455 Vector<T, Rows> operator* (const Matrix<T, Rows, Cols>& mtx, const Vector<T, Cols>& vec)
456 {
457         Vector<T, Rows> res;
458         for (int row = 0; row < Rows; row++)
459         {
460                 T v = T(0);
461                 for (int col = 0; col < Cols; col++)
462                         v += mtx(row,col) * vec.m_data[col];
463                 res.m_data[row] = v;
464         }
465         return res;
466 }
467
468 // Multiply of matrix with row vector.
469 template <typename T, int Rows, int Cols>
470 Vector<T, Cols> operator* (const Vector<T, Rows>& vec, const Matrix<T, Rows, Cols>& mtx)
471 {
472         Vector<T, Cols> res;
473         for (int col = 0; col < Cols; col++)
474         {
475                 T v = T(0);
476                 for (int row = 0; row < Rows; row++)
477                         v += mtx(row,col) * vec.m_data[row];
478                 res.m_data[col] = v;
479         }
480         return res;
481 }
482
483 // Common typedefs.
484 typedef Matrix<float, 2, 2>             Matrix2f;
485 typedef Matrix<float, 3, 3>             Matrix3f;
486 typedef Matrix<float, 4, 4>             Matrix4f;
487 typedef Matrix<double, 2, 2>    Matrix2d;
488 typedef Matrix<double, 3, 3>    Matrix3d;
489 typedef Matrix<double, 4, 4>    Matrix4d;
490
491 // GLSL-style naming \note CxR.
492 typedef Matrix2f                        Mat2;
493 typedef Matrix<float, 3, 2>     Mat2x3;
494 typedef Matrix<float, 4, 2>     Mat2x4;
495 typedef Matrix<float, 2, 3>     Mat3x2;
496 typedef Matrix3f                        Mat3;
497 typedef Matrix<float, 4, 3>     Mat3x4;
498 typedef Matrix<float, 2, 4>     Mat4x2;
499 typedef Matrix<float, 3, 4>     Mat4x3;
500 typedef Matrix4f                        Mat4;
501
502 // Matrix-scalar operators.
503
504 template <typename T, int Rows, int Cols>
505 Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
506 {
507         Matrix<T, Rows, Cols> res;
508         for (int col = 0; col < Cols; col++)
509                 for (int row = 0; row < Rows; row++)
510                         res(row, col) = mtx(row, col) + scalar;
511         return res;
512 }
513
514 template <typename T, int Rows, int Cols>
515 Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
516 {
517         Matrix<T, Rows, Cols> res;
518         for (int col = 0; col < Cols; col++)
519                 for (int row = 0; row < Rows; row++)
520                         res(row, col) = mtx(row, col) - scalar;
521         return res;
522 }
523
524 template <typename T, int Rows, int Cols>
525 Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
526 {
527         Matrix<T, Rows, Cols> res;
528         for (int col = 0; col < Cols; col++)
529                 for (int row = 0; row < Rows; row++)
530                         res(row, col) = mtx(row, col) * scalar;
531         return res;
532 }
533
534 template <typename T, int Rows, int Cols>
535 Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
536 {
537         Matrix<T, Rows, Cols> res;
538         for (int col = 0; col < Cols; col++)
539                 for (int row = 0; row < Rows; row++)
540                         res(row, col) = mtx(row, col) / scalar;
541         return res;
542 }
543
544 // Matrix-matrix component-wise operators.
545
546 template <typename T, int Rows, int Cols>
547 Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
548 {
549         Matrix<T, Rows, Cols> res;
550         for (int col = 0; col < Cols; col++)
551                 for (int row = 0; row < Rows; row++)
552                         res(row, col) = a(row, col) + b(row, col);
553         return res;
554 }
555
556 template <typename T, int Rows, int Cols>
557 Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
558 {
559         Matrix<T, Rows, Cols> res;
560         for (int col = 0; col < Cols; col++)
561                 for (int row = 0; row < Rows; row++)
562                         res(row, col) = a(row, col) - b(row, col);
563         return res;
564 }
565
566 template <typename T, int Rows, int Cols>
567 Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
568 {
569         Matrix<T, Rows, Cols> res;
570         for (int col = 0; col < Cols; col++)
571                 for (int row = 0; row < Rows; row++)
572                         res(row, col) = a(row, col) / b(row, col);
573         return res;
574 }
575
576 } // tcu
577
578 #endif // _TCUMATRIX_HPP