Main Page | Compound List | File List | Compound Members

gmatrix.h

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

Generated on Thu Aug 12 16:22:27 2004 for GMATRIX by doxygen 1.3.3