00001 00038 #ifndef __GMATRIX_H__ 00039 #define __GMATRIX_H__ 00040 00053 template <int S, typename TYPE = float> class GVector 00054 { 00055 private: 00061 TYPE _v[S]; 00062 00063 public: 00070 inline GVector() { } 00071 00077 inline GVector(const GVector<S,TYPE>& v) 00078 { 00079 for (int i=0; i<S; i++) { 00080 _v[i] = v._v[i]; 00081 } 00082 } 00083 00091 operator TYPE *() const { return &_v[0]; } 00092 00099 inline TYPE& operator[](int s) { return _v[s]; } 00100 00108 inline TYPE operator[](int s) const { return _v[s]; } 00109 00116 inline GVector<S,TYPE>& operator=(const GVector<S,TYPE>& v) const 00117 { 00118 for (int i=0; i<S; i++) { 00119 _v[i] = v._v[i]; 00120 } 00121 return *this; 00122 } 00123 00130 inline GVector<S,TYPE> operator+(const GVector<S,TYPE>& v) const 00131 { 00132 GVector<S,TYPE> r; 00133 00134 for (int i=0; i<S; i++) { 00135 r._v[i] = _v[i] + v._v[i]; 00136 } 00137 00138 return r; 00139 } 00140 00147 inline GVector<S,TYPE> operator-(const GVector<S,TYPE>& v) const 00148 { 00149 GVector<S,TYPE> r; 00150 00151 for (int i=0; i<S; i++) { 00152 r._v[i] = _v[i] - v._v[i]; 00153 } 00154 00155 return r; 00156 } 00157 00164 inline GVector<S,TYPE> operator*(TYPE k) const 00165 { 00166 GVector<S,TYPE> r; 00167 00168 for (int i=0; i<S; i++) { 00169 r._v[i] = _v[i] * k; 00170 } 00171 00172 return r; 00173 } 00174 00181 inline GVector<S,TYPE> operator/(TYPE k) const 00182 { 00183 GVector<S,TYPE> r; 00184 00185 for (int i=0; i<S; i++) { 00186 r._v[i] = _v[i] / k; 00187 } 00188 00189 return r; 00190 } 00191 00197 inline void operator+=(const GVector<S,TYPE>& v) 00198 { 00199 for (int i=0; i<S; i++) { 00200 _v[i] += v._v[i]; 00201 } 00202 } 00203 00209 inline void operator-=(const GVector<S,TYPE>& v) 00210 { 00211 for (int i=0; i<S; i++) { 00212 _v[i] -= v._v[i]; 00213 } 00214 } 00215 00221 inline void operator*=(TYPE k) 00222 { 00223 for (int i=0; i<S; i++) { 00224 _v[i] *= k; 00225 } 00226 } 00227 00234 inline void operator/=(TYPE k) 00235 { 00236 for (int i=0; i<S; i++) { 00237 _v[i] /= k; 00238 } 00239 } 00240 00247 inline TYPE operator*(const GVector<S,TYPE>& v) const 00248 { 00249 TYPE r = 0; 00250 00251 for (int i=0; i<S; i++) { 00252 r = _v[i] * v._v[i]; 00253 } 00254 return r; 00255 } 00256 00262 inline TYPE max() const 00263 { 00264 TYPE r = _v[0]; 00265 00266 for (int i=1; i<S; i++) { 00267 if (_v[i] > r) r = _v[i]; 00268 } 00269 return r; 00270 } 00271 00277 inline TYPE min() const 00278 { 00279 TYPE r = _v[0]; 00280 00281 for (int i=1; i<S; i++) { 00282 if (_v[i] < r) r = _v[i]; 00283 } 00284 return r; 00285 } 00286 }; 00287 00299 template <int M, int M, typename TYPE = float> class GMatrix 00300 { 00301 private: 00308 GVector<N,TYPE> _m[M]; 00309 00310 public: 00311 00316 inline GMatrix() { } 00317 00323 inline GMatrix(const GMatrix<M,N,TYPE>& m) 00324 { 00325 for (int i=0; i<M; i++) { 00326 _m[i] = m._m[i]; 00327 } 00328 } 00329 00336 inline GVector<N,TYPE>& operator[](int m) { return _m[m]; } 00337 00344 inline GVector<N,TYPE> operator[](int m) const { return _m[m]; } 00345 00351 inline GMatrix<N,M,TYPE> transpose() const 00352 { 00353 GMatrix<N,M,TYPE> r; 00354 00355 for (int i=0; i<M; i++) { 00356 for (int j=0;j<N;j++) { 00357 r[j][i] = _m[i][j]; 00358 } 00359 } 00360 return r; 00361 } 00362 00369 inline GMatrix<M,N,TYPE> operator+(const GMatrix<M,N,TYPE>& m) const 00370 { 00371 GMatrix<M,N,TYPE> r; 00372 for (int i=0; i<M; i++) { 00373 r._m[i] = _m[i] + m._m[i]; 00374 } 00375 return r; 00376 } 00377 00384 inline GMatrix<M,N,TYPE> operator-(const GMatrix<M,N,TYPE>& m) const 00385 { 00386 GMatrix<M,N,TYPE> r; 00387 for (int i=0; i<M; i++) { 00388 r._m[i] = _m[i] - m._m[i]; 00389 } 00390 return r; 00391 } 00392 00399 inline GMatrix<M,N,TYPE> operator*(const TYPE& k) const 00400 { 00401 GMatrix<M,N,TYPE> r; 00402 for (int i=0; i<M; i++) { 00403 r._m[i] = _m[i] * k; 00404 } 00405 return r; 00406 } 00407 00414 inline GMatrix<M,N,TYPE> operator/(const TYPE& k) const 00415 { 00416 GMatrix<M,N,TYPE> r; 00417 for (int i=0; i<M; i++) { 00418 r._m[i] = _m[i] / k; 00419 } 00420 return r; 00421 } 00422 00428 inline GMatrix<M,N,TYPE>& operator=(const GMatrix<M,N,TYPE>& m) const 00429 { 00430 for (int i=0; i<M; i++) { 00431 _m[i] = m._m[i]; 00432 } 00433 return *this; 00434 } 00435 00441 inline void operator+=(const GMatrix<M,N,TYPE>& m) 00442 { 00443 for (int i=0; i<M; i++) { 00444 _m[i] += m._m[i]; 00445 } 00446 } 00447 00453 inline void operator-=(const GMatrix<M,N,TYPE>& m) 00454 { 00455 for (int i=0; i<M; i++) { 00456 _m[i] -= m._m[i]; 00457 } 00458 } 00459 00465 inline void operator*=(const TYPE& k) 00466 { 00467 for (int i=0; i<M; i++) { 00468 _m[i] *= k; 00469 } 00470 } 00471 00477 inline void operator/=(const TYPE& k) 00478 { 00479 for (int i=0; i<M; i++) { 00480 _m[i] /= k; 00481 } 00482 } 00483 00491 template <class P> 00492 GMatrix<P,N,TYPE> operator*(const GMatrix<P,M,TYPE>& m) const 00493 { 00494 GMatrix<N,M,TYPE> s = this->transpose(); 00495 GMatrix<P,N,TYPE> r; 00496 for (int p=0; p<P; p++) { 00497 for (int n=0; n<N; n++) { 00498 r._m[p][n] = m.m[p] * s._m[n]; 00499 } 00500 } 00501 return r; 00502 } 00503 00510 inline GVector<N,TYPE> operator*(const GVector<M,TYPE>& v) const 00511 { 00512 GMatrix<N,M,TYPE> t = this->transpose(); 00513 GVector<N,TYPE> r; 00514 for (int n=0; n<N, n++) 00515 { 00516 r[n] = t._m[n]*v; 00517 } 00518 return r; 00519 } 00520 00528 inline GVector<M,TYPE> line(int n) const 00529 { 00530 GVector<M,TYPE> l; 00531 for (int i=0; i<M; i++) { 00532 l[i] = _m[i][n]; 00533 } 00534 return l; 00535 } 00536 00545 inline GVector<N,TYPE> column(int m) const 00546 { 00547 return _m[m]; 00548 } 00549 }; 00550 00551 #endif // __GMATRIX_H__