00001 00041 #ifndef __GMATRIX_H__ 00042 #define __GMATRIX_H__ 00043 00044 namespace gmatrix 00045 { 00046 00047 static const char *version = "0.0.2"; 00048 00061 template <int S, typename TYPE = float> class GVector 00062 { 00063 private: 00069 TYPE _v[S]; 00070 00071 public: 00078 inline GVector() { } 00079 00085 inline GVector(const GVector<S,TYPE>& v) 00086 { 00087 for (int i=0; i<S; i++) { 00088 _v[i] = v._v[i]; 00089 } 00090 } 00091 00099 operator TYPE *() const { return &_v[0]; } 00100 00107 inline TYPE& operator[](int s) { return _v[s]; } 00108 00116 inline TYPE operator[](int s) const { return _v[s]; } 00117 00124 inline GVector<S,TYPE>& operator=(const GVector<S,TYPE>& v) 00125 { 00126 for (int i=0; i<S; i++) { 00127 _v[i] = v._v[i]; 00128 } 00129 return *this; 00130 } 00131 00138 inline GVector<S,TYPE> operator+(const GVector<S,TYPE>& v) const 00139 { 00140 GVector<S,TYPE> r; 00141 00142 for (int i=0; i<S; i++) { 00143 r._v[i] = _v[i] + v._v[i]; 00144 } 00145 00146 return r; 00147 } 00148 00155 inline GVector<S,TYPE> operator-(const GVector<S,TYPE>& v) const 00156 { 00157 GVector<S,TYPE> r; 00158 00159 for (int i=0; i<S; i++) { 00160 r._v[i] = _v[i] - v._v[i]; 00161 } 00162 00163 return r; 00164 } 00165 00172 inline GVector<S,TYPE> operator*(TYPE k) const 00173 { 00174 GVector<S,TYPE> r; 00175 00176 for (int i=0; i<S; i++) { 00177 r._v[i] = _v[i] * k; 00178 } 00179 00180 return r; 00181 } 00182 00189 inline GVector<S,TYPE> operator/(TYPE k) const 00190 { 00191 GVector<S,TYPE> r; 00192 00193 for (int i=0; i<S; i++) { 00194 r._v[i] = _v[i] / k; 00195 } 00196 00197 return r; 00198 } 00199 00205 inline void operator+=(const GVector<S,TYPE>& v) 00206 { 00207 for (int i=0; i<S; i++) { 00208 _v[i] += v._v[i]; 00209 } 00210 } 00211 00217 inline void operator-=(const GVector<S,TYPE>& v) 00218 { 00219 for (int i=0; i<S; i++) { 00220 _v[i] -= v._v[i]; 00221 } 00222 } 00223 00229 inline void operator*=(TYPE k) 00230 { 00231 for (int i=0; i<S; i++) { 00232 _v[i] *= k; 00233 } 00234 } 00235 00242 inline void operator/=(TYPE k) 00243 { 00244 for (int i=0; i<S; i++) { 00245 _v[i] /= k; 00246 } 00247 } 00248 00255 inline TYPE operator*(const GVector<S,TYPE>& v) const 00256 { 00257 TYPE r = 0; 00258 00259 for (int i=0; i<S; i++) { 00260 r = _v[i] * v._v[i]; 00261 } 00262 return r; 00263 } 00264 00270 inline TYPE max() const 00271 { 00272 TYPE r = _v[0]; 00273 00274 for (int i=1; i<S; i++) { 00275 if (_v[i] > r) r = _v[i]; 00276 } 00277 return r; 00278 } 00279 00285 inline TYPE min() const 00286 { 00287 TYPE r = _v[0]; 00288 00289 for (int i=1; i<S; i++) { 00290 if (_v[i] < r) r = _v[i]; 00291 } 00292 return r; 00293 } 00294 }; 00295 00303 template <int S, typename TYPE> inline GVector<S,TYPE> operator*(const TYPE& k, const GVector<S,TYPE>& v) 00304 { 00305 GVector<S,TYPE> r; 00306 00307 for (int i=0; i<S; i++) { 00308 r._v[i] = v._v[i] * k; 00309 } 00310 00311 return r; 00312 } 00313 00325 template <int M, int N, typename TYPE = float> class GMatrix 00326 { 00327 private: 00334 GVector<N,TYPE> _m[M]; 00335 00336 public: 00337 00342 inline GMatrix() { } 00343 00349 inline GMatrix(const GMatrix<M,N,TYPE>& m) 00350 { 00351 for (int i=0; i<M; i++) { 00352 _m[i] = m._m[i]; 00353 } 00354 } 00355 00362 inline GVector<N,TYPE>& operator[](int m) { return _m[m]; } 00363 00370 inline const GVector<N,TYPE>& operator[](int m) const { return _m[m]; } 00371 00377 inline GMatrix<N,M,TYPE> transpose() const 00378 { 00379 GMatrix<N,M,TYPE> r; 00380 for (int i=0; i<M; i++) { 00381 for (int j=0;j<N;j++) { 00382 r[j][i] = _m[i][j]; 00383 } 00384 } 00385 return r; 00386 } 00387 00394 inline GMatrix<M,N,TYPE> operator+(const GMatrix<M,N,TYPE>& m) const 00395 { 00396 GMatrix<M,N,TYPE> r; 00397 for (int i=0; i<M; i++) { 00398 r._m[i] = _m[i] + m._m[i]; 00399 } 00400 return r; 00401 } 00402 00409 inline GMatrix<M,N,TYPE> operator-(const GMatrix<M,N,TYPE>& m) const 00410 { 00411 GMatrix<M,N,TYPE> r; 00412 for (int i=0; i<M; i++) { 00413 r._m[i] = _m[i] - m._m[i]; 00414 } 00415 return r; 00416 } 00417 00424 inline GMatrix<M,N,TYPE> operator*(const TYPE& k) const 00425 { 00426 GMatrix<M,N,TYPE> r; 00427 for (int i=0; i<M; i++) { 00428 r._m[i] = _m[i] * k; 00429 } 00430 return r; 00431 } 00432 00439 inline GMatrix<M,N,TYPE> operator/(const TYPE& k) const 00440 { 00441 GMatrix<M,N,TYPE> r; 00442 for (int i=0; i<M; i++) { 00443 r._m[i] = _m[i] / k; 00444 } 00445 return r; 00446 } 00447 00453 inline GMatrix<M,N,TYPE>& operator=(const GMatrix<M,N,TYPE>& m) 00454 { 00455 for (int i=0; i<M; i++) { 00456 _m[i] = m._m[i]; 00457 } 00458 return *this; 00459 } 00460 00466 inline void operator+=(const GMatrix<M,N,TYPE>& m) 00467 { 00468 for (int i=0; i<M; i++) { 00469 _m[i] += m._m[i]; 00470 } 00471 } 00472 00478 inline void operator-=(const GMatrix<M,N,TYPE>& m) 00479 { 00480 for (int i=0; i<M; i++) { 00481 _m[i] -= m._m[i]; 00482 } 00483 } 00484 00490 inline void operator*=(const TYPE& k) 00491 { 00492 for (int i=0; i<M; i++) { 00493 _m[i] *= k; 00494 } 00495 } 00496 00502 inline void operator/=(const TYPE& k) 00503 { 00504 for (int i=0; i<M; i++) { 00505 _m[i] /= k; 00506 } 00507 } 00508 00516 template <int P> GMatrix<P,N,TYPE> operator*(const GMatrix<P,M,TYPE>& m) const 00517 { 00518 GMatrix<N,M,TYPE> s = this->transpose(); 00519 GMatrix<P,N,TYPE> r; 00520 for (int p=0; p<P; p++) { 00521 for (int n=0; n<N; n++) { 00522 r[p][n] = m[p] * s[n]; 00523 } 00524 } 00525 return r; 00526 } 00527 00534 inline GVector<N,TYPE> operator*(const GVector<M,TYPE>& v) const 00535 { 00536 GMatrix<N,M,TYPE> t = this->transpose(); 00537 GVector<N,TYPE> r; 00538 for (int n=0; n<N; n++) { 00539 r[n] = t[n]*v; 00540 } 00541 return r; 00542 } 00543 00553 inline GVector<M,TYPE> premul(const GVector<N,TYPE>& v) const 00554 { 00555 GVector<M,TYPE> r; 00556 for (int m=0; m<M; m++) { 00557 r[m] = v*_m[m]; 00558 } 00559 return r; 00560 } 00561 00569 inline GVector<M,TYPE> line(int n) const 00570 { 00571 GVector<M,TYPE> l; 00572 for (int i=0; i<M; i++) { 00573 l[i] = _m[i][n]; 00574 } 00575 return l; 00576 } 00577 00586 inline GVector<N,TYPE> column(int m) const 00587 { 00588 return _m[m]; 00589 } 00590 00591 }; 00592 00600 template <int M, int N, typename TYPE> inline GMatrix<M,N,TYPE> operator*(const TYPE& k, const GMatrix<M,N,TYPE>& m) 00601 { 00602 GMatrix<M,N,TYPE> r; 00603 for (int i=0; i<M; i++) { 00604 r[i] = m[i] * k; 00605 } 00606 return r; 00607 } 00608 00609 }; 00610 00611 #endif // __GMATRIX_H__