Mercurial > Math

view src/Matrix.cpp @ 6:11e216148d1c

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