Main Page | Compound List | File List | Compound Members

gmatrix.h

Go to the documentation of this file.
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__

Generated on Tue Aug 3 12:08:13 2004 for GMATRIX by doxygen 1.3.3