Mercurial > Math

view include/Matrix.h @ 7:378862555189

find changesets by author, revision, files, or words in the commit message
Refactored Vectors into templated classes. Much nicer now.
author Eris Caffee <discordia@eldalin.com>
date Wed, 28 Sep 2011 12:48:42 -0500
parents 11e216148d1c
children 81d2aa42a860
line source
1 #ifndef MATRIX_H_
2 #define MATRIX_H_
3
4 #include "Vector.h"
5 using namespace arda::Vector;
6
7 #include <cmath>
8 #include <string>
9
10 namespace arda
11 {
12 namespace Matrix
13 {
14 //////////////////////////////////////////////////////////////////////////
15 // Maxtrices
16 //
17 // Supported operations on matrices
18 //
19 // getstring*() Returns a printable string representation of the matrix.
20 // assign*() Assign the value of one matrix to another.
21 // add*() Add two matrices
22 // subtract*() A convenience function to avoid writing
23 // add(m1, scale(m2, -1))
24 // transpose*() Returns the transpose of a matrix.
25 // scale*() Multiplies a matrix by a scalar.
26 // multvec*() Multiplies a matrix by a vector.
27 // multmat*() Multiplies a matrix by another matrix.
28 // det*() Calculates the determinant of a matrix.
29 // inverse*() Returns the inverse of a non-singular matrix.
30 // setidentity*() Sets a matrix to the identity matrix.
31 // getcol*() Returns the vector that is column n of the matrix.
32 // setcol*() Set the vector that is column n of the matrix.
33 //
34 // assign*(), add*(), and subtract*() are defined inline, though this might
35 // might not be the best thing. Some real world testing is needed to decide
36 // whether or not htye should be remain inline.
37
38 typedef int Matrix2i[4];
39 typedef float Matrix2f[4];
40 typedef double Matrix2d[4];
41
42 typedef int Matrix3i[9];
43 typedef float Matrix3f[9];
44 typedef double Matrix3d[9];
45
46 typedef int Matrix4i[16];
47 typedef float Matrix4f[16];
48 typedef double Matrix4d[16];
49
50 //////////////////////////////////////////////////////////////////////////
51 // getstring*()
52 std::string & getstring2m(Matrix2i m, std::string & s);
53 std::string & getstring2m(Matrix2f m, std::string & s);
54 std::string & getstring2m(Matrix2d m, std::string & s);
55
56 std::string & getstring3m(Matrix3i m, std::string & s);
57 std::string & getstring3m(Matrix3f m, std::string & s);
58 std::string & getstring3m(Matrix3d m, std::string & s);
59
60 std::string & getstring4m(Matrix4i m, std::string & s);
61 std::string & getstring4m(Matrix4f m, std::string & s);
62 std::string & getstring4m(Matrix4d m, std::string & s);
63
64 //////////////////////////////////////////////////////////////////////////
65 // assign*()
66
67 inline int * assign2m(Matrix2i m1, Matrix2i m2)
68 {
69 m1[0] = m2[0]; m1[1] = m2[1];
70 m1[2] = m2[2]; m1[3] = m2[3];
71 return m1;
72 }
73 inline float * assign2m(Matrix2f m1, Matrix2f m2)
74 {
75 m1[0] = m2[0]; m1[1] = m2[1];
76 m1[2] = m2[2]; m1[3] = m2[3];
77 return m1;
78 }
79 inline double * assign2m(Matrix2d m1, Matrix2d m2)
80 {
81 m1[0] = m2[0]; m1[1] = m2[1];
82 m1[2] = m2[2]; m1[3] = m2[3];
83 return m1;
84 }
85
86 inline int * assign3m(Matrix3i m1, Matrix3i m2)
87 {
88 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2];
89 m1[3] = m2[3]; m1[4] = m2[4]; m1[5] = m2[5];
90 m1[6] = m2[6]; m1[7] = m2[7]; m1[8] = m2[8];
91 return m1;
92 }
93 inline float * assign3m(Matrix3f m1, Matrix3f m2)
94 {
95 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2];
96 m1[3] = m2[3]; m1[4] = m2[4]; m1[5] = m2[5];
97 m1[6] = m2[6]; m1[7] = m2[7]; m1[8] = m2[8];
98 return m1;
99 }
100 inline double * assign3m(Matrix3d m1, Matrix3d m2)
101 {
102 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2];
103 m1[3] = m2[3]; m1[4] = m2[4]; m1[5] = m2[5];
104 m1[6] = m2[6]; m1[7] = m2[7]; m1[8] = m2[8];
105 return m1;
106 }
107
108 inline int * assign4m(Matrix4i m1, Matrix4i m2)
109 {
110 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2]; m1[3] = m2[3];
111 m1[4] = m2[4]; m1[5] = m2[5]; m1[6] = m2[6]; m1[7] = m2[7];
112 m1[8] = m2[8]; m1[9] = m2[9]; m1[10] = m2[10]; m1[11] = m2[11];
113 m1[12] = m2[12]; m1[13] = m2[13]; m1[14] = m2[14]; m1[15] = m2[15];
114 return m1;
115 }
116 inline float * assign4m(Matrix4f m1, Matrix4f m2)
117 {
118 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2]; m1[3] = m2[3];
119 m1[4] = m2[4]; m1[5] = m2[5]; m1[6] = m2[6]; m1[7] = m2[7];
120 m1[8] = m2[8]; m1[9] = m2[9]; m1[10] = m2[10]; m1[11] = m2[11];
121 m1[12] = m2[12]; m1[13] = m2[13]; m1[14] = m2[14]; m1[15] = m2[15];
122 return m1;
123 }
124 inline double * assign4m(Matrix4d m1, Matrix4d m2)
125 {
126 m1[0] = m2[0]; m1[1] = m2[1]; m1[2] = m2[2]; m1[3] = m2[3];
127 m1[4] = m2[4]; m1[5] = m2[5]; m1[6] = m2[6]; m1[7] = m2[7];
128 m1[8] = m2[8]; m1[9] = m2[9]; m1[10] = m2[10]; m1[11] = m2[11];
129 m1[12] = m2[12]; m1[13] = m2[13]; m1[14] = m2[14]; m1[15] = m2[15];
130 return m1;
131 }
132
133 //////////////////////////////////////////////////////////////////////////
134 // add*()
135
136 inline int * add2m(Matrix2i m1, Matrix2i m2)
137 {
138 m1[0] += m2[0]; m1[1] += m2[1];
139 m1[2] += m2[2]; m1[3] += m2[3];
140 return m1;
141 }
142 inline float * add2m(Matrix2f m1, Matrix2f m2)
143 {
144 m1[0] += m2[0]; m1[1] += m2[1];
145 m1[2] += m2[2]; m1[3] += m2[3];
146 return m1;
147 }
148 inline double * add2m(Matrix2d m1, Matrix2d m2)
149 {
150 m1[0] += m2[0]; m1[1] += m2[1];
151 m1[2] += m2[2]; m1[3] += m2[3];
152 return m1;
153 }
154
155 inline int * add3m(Matrix3i m1, Matrix3i m2)
156 {
157 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2];
158 m1[3] += m2[3]; m1[4] += m2[4]; m1[5] += m2[5];
159 m1[6] += m2[6]; m1[7] += m2[7]; m1[8] += m2[8];
160 return m1;
161 }
162 inline float * add3m(Matrix3f m1, Matrix3f m2)
163 {
164 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2];
165 m1[3] += m2[3]; m1[4] += m2[4]; m1[5] += m2[5];
166 m1[6] += m2[6]; m1[7] += m2[7]; m1[8] += m2[8];
167 return m1;
168 }
169 inline double * add3m(Matrix3d m1, Matrix3d m2)
170 {
171 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2];
172 m1[3] += m2[3]; m1[4] += m2[4]; m1[5] += m2[5];
173 m1[6] += m2[6]; m1[7] += m2[7]; m1[8] += m2[8];
174 return m1;
175 }
176
177 inline int * add4m(Matrix4i m1, Matrix4i m2)
178 {
179 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2]; m1[3] += m2[3];
180 m1[4] += m2[4]; m1[5] += m2[5]; m1[6] += m2[6]; m1[7] += m2[7];
181 m1[8] += m2[8]; m1[9] += m2[9]; m1[10] += m2[10]; m1[11] += m2[11];
182 m1[12] += m2[12]; m1[13] += m2[13]; m1[14] += m2[14]; m1[15] += m2[15];
183 return m1;
184 }
185 inline float * add4m(Matrix4f m1, Matrix4f m2)
186 {
187 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2]; m1[3] += m2[3];
188 m1[4] += m2[4]; m1[5] += m2[5]; m1[6] += m2[6]; m1[7] += m2[7];
189 m1[8] += m2[8]; m1[9] += m2[9]; m1[10] += m2[10]; m1[11] += m2[11];
190 m1[12] += m2[12]; m1[13] += m2[13]; m1[14] += m2[14]; m1[15] += m2[15];
191 return m1;
192 }
193 inline double * add4m(Matrix4d m1, Matrix4d m2)
194 {
195 m1[0] += m2[0]; m1[1] += m2[1]; m1[2] += m2[2]; m1[3] += m2[3];
196 m1[4] += m2[4]; m1[5] += m2[5]; m1[6] += m2[6]; m1[7] += m2[7];
197 m1[8] += m2[8]; m1[9] += m2[9]; m1[10] += m2[10]; m1[11] += m2[11];
198 m1[12] += m2[12]; m1[13] += m2[13]; m1[14] += m2[14]; m1[15] += m2[15];
199 return m1;
200 }
201
202 //////////////////////////////////////////////////////////////////////////
203 // subtract*()
204
205 inline int * subtract2m(Matrix2i m1, Matrix2i m2)
206 {
207 m1[0] -= m2[0]; m1[1] -= m2[1];
208 m1[2] -= m2[2]; m1[3] -= m2[3];
209 return m1;
210 }
211 inline float * subtract2m(Matrix2f m1, Matrix2f m2)
212 {
213 m1[0] -= m2[0]; m1[1] -= m2[1];
214 m1[2] -= m2[2]; m1[3] -= m2[3];
215 return m1;
216 }
217 inline double * subtract2m(Matrix2d m1, Matrix2d m2)
218 {
219 m1[0] -= m2[0]; m1[1] -= m2[1];
220 m1[2] -= m2[2]; m1[3] -= m2[3];
221 return m1;
222 }
223
224 inline int * subtract3m(Matrix3i m1, Matrix3i m2)
225 {
226 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2];
227 m1[3] -= m2[3]; m1[4] -= m2[4]; m1[5] -= m2[5];
228 m1[6] -= m2[6]; m1[7] -= m2[7]; m1[8] -= m2[8];
229 return m1;
230 }
231 inline float * subtract3m(Matrix3f m1, Matrix3f m2)
232 {
233 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2];
234 m1[3] -= m2[3]; m1[4] -= m2[4]; m1[5] -= m2[5];
235 m1[6] -= m2[6]; m1[7] -= m2[7]; m1[8] -= m2[8];
236 return m1;
237 }
238 inline double * subtract3m(Matrix3d m1, Matrix3d m2)
239 {
240 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2];
241 m1[3] -= m2[3]; m1[4] -= m2[4]; m1[5] -= m2[5];
242 m1[6] -= m2[6]; m1[7] -= m2[7]; m1[8] -= m2[8];
243 return m1;
244 }
245
246 inline int * subtract4m(Matrix4i m1, Matrix4i m2)
247 {
248 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2]; m1[3] -= m2[3];
249 m1[4] -= m2[4]; m1[5] -= m2[5]; m1[6] -= m2[6]; m1[7] -= m2[7];
250 m1[8] -= m2[8]; m1[9] -= m2[9]; m1[10] -= m2[10]; m1[11] -= m2[11];
251 m1[12] -= m2[12]; m1[13] -= m2[13]; m1[14] -= m2[14]; m1[15] -= m2[15];
252 return m1;
253 }
254 inline float * subtract4m(Matrix4f m1, Matrix4f m2)
255 {
256 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2]; m1[3] -= m2[3];
257 m1[4] -= m2[4]; m1[5] -= m2[5]; m1[6] -= m2[6]; m1[7] -= m2[7];
258 m1[8] -= m2[8]; m1[9] -= m2[9]; m1[10] -= m2[10]; m1[11] -= m2[11];
259 m1[12] -= m2[12]; m1[13] -= m2[13]; m1[14] -= m2[14]; m1[15] -= m2[15];
260 return m1;
261 }
262 inline double * subtract4m(Matrix4d m1, Matrix4d m2)
263 {
264 m1[0] -= m2[0]; m1[1] -= m2[1]; m1[2] -= m2[2]; m1[3] -= m2[3];
265 m1[4] -= m2[4]; m1[5] -= m2[5]; m1[6] -= m2[6]; m1[7] -= m2[7];
266 m1[8] -= m2[8]; m1[9] -= m2[9]; m1[10] -= m2[10]; m1[11] -= m2[11];
267 m1[12] -= m2[12]; m1[13] -= m2[13]; m1[14] -= m2[14]; m1[15] -= m2[15];
268 return m1;
269 }
270
271 //////////////////////////////////////////////////////////////////////////
272 // scale*()
273
274 inline int * scale2m(Matrix2i m, int s)
275 {
276 m[0] *= s; m[1] *= s;
277 m[2] *= s; m[3] *= s;
278 return m;
279 }
280 inline float * scale2m(Matrix2f m, float s)
281 {
282 m[0] *= s; m[1] *= s;
283 m[2] *= s; m[3] *= s;
284 return m;
285 }
286 inline double * scale2m(Matrix2d m, double s)
287 {
288 m[0] *= s; m[1] *= s;
289 m[2] *= s; m[3] *= s;
290 return m;
291 }
292
293 inline int * scale3m(Matrix3i m, int s)
294 {
295 m[0] *= s; m[1] *= s; m[2] *= s;
296 m[3] *= s; m[4] *= s; m[5] *= s;
297 m[4] *= s; m[5] *= s; m[6] *= s;
298 return m;
299 }
300 inline float * scale3m(Matrix3f m, float s)
301 {
302 m[0] *= s; m[1] *= s; m[2] *= s;
303 m[3] *= s; m[4] *= s; m[5] *= s;
304 m[4] *= s; m[5] *= s; m[6] *= s;
305 return m;
306 }
307 inline double * scale3m(Matrix3d m, double s)
308 {
309 m[0] *= s; m[1] *= s; m[2] *= s;
310 m[3] *= s; m[4] *= s; m[5] *= s;
311 m[4] *= s; m[5] *= s; m[6] *= s;
312 return m;
313 }
314
315 inline int * scale4m(Matrix4i m, int s)
316 {
317 m[0] *= s; m[1] *= s; m[2] *= s; m[3] *= s;
318 m[4] *= s; m[5] *= s; m[4] *= s; m[5] *= s;
319 m[6] *= s; m[7] *= s; m[8] *= s; m[9] *= s;
320 m[10] *= s; m[11] *= s; m[12] *= s; m[13] *= s;
321 return m;
322 }
323 inline float * scale4m(Matrix4f m, float s)
324 {
325 m[0] *= s; m[1] *= s; m[2] *= s; m[3] *= s;
326 m[4] *= s; m[5] *= s; m[4] *= s; m[5] *= s;
327 m[6] *= s; m[7] *= s; m[8] *= s; m[9] *= s;
328 m[10] *= s; m[11] *= s; m[12] *= s; m[13] *= s;
329 return m;
330 }
331 inline double * scale4m(Matrix4d m, double s)
332 {
333 m[0] *= s; m[1] *= s; m[2] *= s; m[3] *= s;
334 m[4] *= s; m[5] *= s; m[6] *= s; m[7] *= s;
335 m[8] *= s; m[9] *= s; m[10] *= s; m[11] *= s;
336 m[12] *= s; m[13] *= s; m[14] *= s; m[15] *= s;
337 return m;
338 }
339
340 //////////////////////////////////////////////////////////////////////////
341 // multvec*mv(Matrix m, Vector v, Vector vres)
342 // Right multiplies a matrix m by a (column) vector v and stores
343 // the result in vres.
344 // Returns vres.
345 //
346 // multvec*vm(Vector v, Matrix m, Vector vres)
347 // Left multiplies a (row) vector v by a matrix m and stores the
348 // result in vres.
349 // Returns vres.
350
351 int * multvec2mv(Matrix2i m, Vector2i v, Vector2i vres);
352 float * multvec2mv(Matrix2f m, Vector2f v, Vector2f vres);
353 double * multvec2mv(Matrix2d m, Vector2d v, Vector2d vres);
354
355 int * multvec3mv(Matrix3i m, Vector3i v, Vector3i vres);
356 float * multvec3mv(Matrix3f m, Vector3f v, Vector3f vres);
357 double * multvec3mv(Matrix3d m, Vector3d v, Vector3d vres);
358
359 int * multvec4mv(Matrix4i m, Vector4i v, Vector4i vres);
360 float * multvec4mv(Matrix4f m, Vector4f v, Vector4f vres);
361 double * multvec4mv(Matrix4d m, Vector4d v, Vector4d vres);
362
363 int * multvec2vm(Vector2i v, Matrix2i m, Vector2i vres);
364 float * multvec2vm(Vector2f v, Matrix2f m, Vector2f vres);
365 double * multvec2vm(Vector2d v, Matrix2d m, Vector2d vres);
366
367 int * multvec3vm(Vector3i v, Matrix3i m, Vector3i vres);
368 float * multvec3vm(Vector3f v, Matrix3f m, Vector3f vres);
369 double * multvec3vm(Vector3d v, Matrix3d m, Vector3d vres);
370
371 int * multvec4vm(Vector4i v, Matrix4i m, Vector4i vres);
372 float * multvec4vm(Vector4f v, Matrix4f m, Vector4f vres);
373 double * multvec4vm(Vector4d v, Matrix4d m, Vector4d vres);
374
375 //////////////////////////////////////////////////////////////////////////
376 // multmat*(Matrix m1, Matrix m2, Matrix mres)
377 // Multiply two matrices together and return the result in mres.
378 // returns mres.
379
380 int * multmat2(Matrix2i m1, Matrix2i m2, Matrix2i mres);
381 float * multmat2(Matrix2f m1, Matrix2f m2, Matrix2f mres);
382 double * multmat2(Matrix2d m1, Matrix2d m2, Matrix2d mres);
383
384 int * multmat3(Matrix3i m1, Matrix3i m2, Matrix3i mres);
385 float * multmat3(Matrix3f m1, Matrix3f m2, Matrix3f mres);
386 double * multmat3(Matrix3d m1, Matrix3d m2, Matrix3d mres);
387
388 int * multmat4(Matrix4i m1, Matrix4i m2, Matrix4i mres);
389 float * multmat4(Matrix4f m1, Matrix4f m2, Matrix4f mres);
390 double * multmat4(Matrix4d m1, Matrix4d m2, Matrix4d mres);
391
392 //////////////////////////////////////////////////////////////////////////
393 // transpose*(Matrix m, Matrix mres)
394 // Compute the transpose of a matrix and store the result in mres.
395 // Returns mres.
396
397 int * transpose2(Matrix2i m, Matrix2i mres);
398 float * transpose2(Matrix2f m, Matrix2f mres);
399 double * transpose2(Matrix2d m, Matrix2d mres);
400
401 int * transpose3(Matrix3i m, Matrix3i mres);
402 float * transpose3(Matrix3f m, Matrix3f mres);
403 double * transpose3(Matrix3d m, Matrix3d mres);
404
405 int * transpose4(Matrix4i m, Matrix4i mres);
406 float * transpose4(Matrix4f m, Matrix4f mres);
407 double * transpose4(Matrix4d m, Matrix4d mres);
408
409 //////////////////////////////////////////////////////////////////////////
410 // det*(Matrix m)
411 // Computer the determinant of a matrix.
412 // Returns the determinant.
413
414 inline double det2(Matrix2i m)
415 { return m[0] * m[3] - m[1] * m[2]; }
416 inline double det2(Matrix2f m)
417 { return m[0] * m[3] - m[1] * m[2]; }
418 inline double det2(Matrix2d m)
419 { return m[0] * m[3] - m[1] * m[2]; }
420
421 inline double det3(Matrix3i m)
422 { return m[0] * ( m[4] * m[8]
423 - m[5] * m[7])
424 - m[3] * ( m[1] * m[8]
425 - m[2] * m[7])
426 + m[6] * ( m[1] * m[5]
427 - m[2] * m[4]); }
428 inline double det3(Matrix3f m)
429 { return m[0] * ( m[4] * m[8]
430 - m[5] * m[7])
431 - m[3] * ( m[1] * m[8]
432 - m[2] * m[7])
433 + m[6] * ( m[1] * m[5]
434 - m[2] * m[4]); }
435 inline double det3(Matrix3d m)
436 { return m[0] * ( m[4] * m[8]
437 - m[5] * m[7])
438 - m[3] * ( m[1] * m[8]
439 - m[2] * m[7])
440 + m[6] * (m[1] * m[5]
441 - m[2] * m[4]); }
442
443 inline double det4(Matrix4i m)
444 { return m[0] * (m[5] * (m[10] * m[15] -
445 m[11] * m[14]) -
446 m[9] * (m[6] * m[15] -
447 m[7] * m[14]) +
448 m[13] * (m[6] * m[11] -
449 m[7] * m[10])) -
450 m[4] * (m[1] * (m[10] * m[15] -
451 m[11] * m[14]) -
452 m[9] * (m[2] * m[15] -
453 m[3] * m[14]) +
454 m[13] * (m[2] * m[11] -
455 m[3] * m[10])) +
456 m[8] * (m[1] * (m[6] * m[15] -
457 m[7] * m[14]) -
458 m[5] * (m[2] * m[15] -
459 m[3] * m[14]) +
460 m[13] * (m[2] * m[7] -
461 m[3] * m[6])) +
462 m[12] * (m[1] * (m[6] * m[11] -
463 m[7] * m[10]) -
464 m[5] * (m[2] * m[11] -
465 m[3] * m[10]) +
466 m[9] * (m[2] * m[7] -
467 m[3] * m[6])); }
468 inline double det4(Matrix4f m)
469 { return m[0] * (m[5] * (m[10] * m[15] -
470 m[11] * m[14]) -
471 m[9] * (m[6] * m[15] -
472 m[7] * m[14]) +
473 m[13] * (m[6] * m[11] -
474 m[7] * m[10])) -
475 m[4] * (m[1] * (m[10] * m[15] -
476 m[11] * m[14]) -
477 m[9] * (m[2] * m[15] -
478 m[3] * m[14]) +
479 m[13] * (m[2] * m[11] -
480 m[3] * m[10])) +
481 m[8] * (m[1] * (m[6] * m[15] -
482 m[7] * m[14]) -
483 m[5] * (m[2] * m[15] -
484 m[3] * m[14]) +
485 m[13] * (m[2] * m[7] -
486 m[3] * m[6])) +
487 m[12] * (m[1] * (m[6] * m[11] -
488 m[7] * m[10]) -
489 m[5] * (m[2] * m[11] -
490 m[3] * m[10]) +
491 m[9] * (m[2] * m[7] -
492 m[3] * m[6])); }
493 inline double det4(Matrix4d m)
494 { return m[0] * (m[5] * (m[10] * m[15] -
495 m[11] * m[14]) -
496 m[9] * (m[6] * m[15] -
497 m[7] * m[14]) +
498 m[13] * (m[6] * m[11] -
499 m[7] * m[10])) -
500 m[4] * (m[1] * (m[10] * m[15] -
501 m[11] * m[14]) -
502 m[9] * (m[2] * m[15] -
503 m[3] * m[14]) +
504 m[13] * (m[2] * m[11] -
505 m[3] * m[10])) +
506 m[8] * (m[1] * (m[6] * m[15] -
507 m[7] * m[14]) -
508 m[5] * (m[2] * m[15] -
509 m[3] * m[14]) +
510 m[13] * (m[2] * m[7] -
511 m[3] * m[6])) +
512 m[12] * (m[1] * (m[6] * m[11] -
513 m[7] * m[10]) -
514 m[5] * (m[2] * m[11] -
515 m[3] * m[10]) +
516 m[9] * (m[2] * m[7] -
517 m[3] * m[6])); }
518 } // namespace Matrix
519
520 } // namespace arda
521 #endif // MATRIX_H_