lib/maracasVisuLib/include/vector.h

   1 ////////////////////////////////////////////////////////////////////////////////
   2 // vector.h
   3 // Creation : 24/02/2000
   4 // Author   : Leonardo FLOREZ VALENCIA
   5 //               l-florez@uniandes.edu.co
   6 //               lflorez@creatis.insa-lyon.fr
   7 // Copyright (C) 2000-2002 Leonardo FLOREZ VALENCIA
   8 //
   9 // This program is free software; you can redistribute it and/or
  10 // modify it under the terms of the GNU General Public License
  11 // as published by the Free Software Foundation; either version 2
  12 // of the License, or (at your option) any later version.
  13 //
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22 ////////////////////////////////////////////////////////////////////////////////
  23
  24 #ifndef GTMLIB__MATH__VECTOR__HXX
  25 #define GTMLIB__MATH__VECTOR__HXX
  26
  27 #include "mathdefs.h"
  28 #include "vmfuncs.h"
  29
  30 /// Vector type IDs
  31 //@{
  32 #define ROW_VECTOR 0x01
  33 #define COL_VECTOR 0x02
  34 //@}
  35
  36 namespace gtm
  37 {
  38     template< class T >
  39     class TMatrix;
  40
  41     /** TVector class.
  42      *
  43      *  This class defines a C++ template to use mathematical vectors
  44      *  in a N space.
  45      *  @see TMatrix
  46      */
  47     template< class T >
  48     class TVector
  49     {
  50     public:
  51
  52         /** Contructors.
  53          *
  54          *  @param N Cardinality.
  55          *  @param data Initial data.
  56          *  @param type Vector type (ROW_VECTOR/COL_VECTOR).
  57          *  @param r Right object (vector or matrix).
  58          *  @param block ANSI array.
  59          *  @param copy Make a copy of given array?
  60          */
  61         //@{
  62         /// Default constructor.
  63         TVector( uint32_t N = 3, T data = ( T )0, int type = COL_VECTOR  );
  64         /// Copy constructor.
  65         TVector( const TVector< T >& r );
  66         /// Use this to treat an ANSI array as a TVector.
  67         TVector( T* block, uint32_t N, bool copy = true, int type = COL_VECTOR );
  68         //@}
  69
  70         /// Destructor.
  71         ~TVector( ) {
  72             if( _myMemory ) VectorFreeMemory< T >( _vector );
  73         };
  74
  75         /// Size change
  76         void SetN( uint32_t N );
  77
  78         /** Assignation operators.
  79          *
  80          *  @param r Right object (vector or matrix).
  81          */
  82         //@{
  83         /// Vector assignation.
  84         TVector< T >& operator=( const TVector< T >& r );
  85         /// Matrix assignation (defined in class TMatrix).
  86         TVector< T >& operator=( TMatrix< T >& r );
  87         /// ANSI assignation (r size must be, at least, N).
  88         TVector< T >& operator=( T* r ) {
  89             VectorAssignMemory< T >( _vector, r, _N );
  90             return( *this );
  91         };
  92         /// Scalar assignation.
  93         TVector< T >& operator=( T r ) {
  94             VectorAssignScalar< T >( _vector, r, _N );
  95             return( *this );
  96         };
  97         //@}
  98
  99         /** Comparation operators.
 100          *
 101          *  @param r Right object.
 102          */
 103         //@{
 104         /// Equality.
 105         bool operator==( const TVector< T >& r );
 106         /// Inequality.
 107         bool operator!=( const TVector< T >& r );
 108         //@}
 109
 110         /// Reference operator.
 111         T& operator()( uint32_t i ) {
 112             return( _vector[ i ] );
 113         };
 114         /// ANSI (C/C++ array) reference.
 115         T* GetAnsiRef( ) {
 116             return( _vector );
 117         };
 118         /// Vector's cardinality.
 119         uint32_t GetN( ) {
 120             return( _N );
 121         };
 122         /// Vector's type (ROW_VECTOR/COL_VECTOR).
 123         int GetType( ) {
 124             return( _type );
 125         };
 126         /// Mathematical norm (L2).
 127         T GetNorm( ) {
 128             return( VectorNorm< T >( _vector, _N ) );
 129         };
 130         /// Normalizes the vector.
 131         void Normalize( ) {
 132             VectorNormalize< T >( _vector, _vector, _N );
 133         };
 134         /// Dot product.
 135         T Dot( const TVector< T >& r ) {
 136             return( VectorDotProduct< T >( _vector, r._vector, GTM_MIN( _N, r._N ) ) );
 137         };
 138
 139         /** Binary operators.
 140          *
 141          *  @param r Right object (vector, matrix or scalar).
 142          */
 143         //@{
 144         /// Addition.
 145         TVector< T > operator+( const TVector< T >& r );
 146         /// Substraction.
 147         TVector< T > operator-( const TVector< T >& r );
 148         /// Cross product.
 149         TVector< T > operator*( const TVector< T >& r );
 150         /// Matrix product (defined in class TMatrix).
 151         TMatrix< T > operator*( TMatrix< T >& r );
 152         /// Scalar product.
 153         TVector< T > operator*( T r );
 154         //@}
 155
 156         /** Self-assignation binary operators.
 157          *
 158          *  @param r Right object (vector, matrix or scalar).
 159          */
 160         //@{
 161         /// Addition.
 162         TVector< T >& operator+=( const TVector< T >& r ) {
 163             *this = *this + r;
 164             return( *this );
 165         };
 166         /// Substraction.
 167         TVector< T >& operator-=( const TVector< T >& r ) {
 168             *this = *this - r;
 169             return( *this );
 170         };
 171         /// Cross product.
 172         TVector< T >& operator*=( const TVector< T >& r ) {
 173             *this = *this * r;
 174             return( *this );
 175         };
 176         /// Scalar product.
 177         TVector< T >& operator*=( T r ) {
 178             *this = *this * r;
 179             return( *this );
 180         };
 181         //@}
 182
 183         /// Unary operators.
 184         //@{
 185         /// Additive inverse.
 186         TVector< T > operator-( );
 187         /// Normalized vector.
 188         TVector< T > operator!( );
 189         /// Transposed vector.
 190         TVector< T > operator~( );
 191         //@}
 192
 193     private:
 194
 195         /// Vector's internal state.
 196         //@{
 197         /// Memory block.
 198         T* _vector;
 199         /// Cardinality.
 200         uint32_t _N;
 201         /// Type (ROW_VECTOR/COL_VECTOR).
 202         int _type;
 203         /// Have I created _vector?
 204         bool _myMemory;
 205         //@}
 206
 207     };
 208
 209 // -----------------------------------------------------------------------------
 210     template< class T >
 211     TVector< T >::TVector( uint32_t N, T data, int type )
 212     {
 213         _N        = N;
 214         _type     = type;
 215         _vector   = VectorAllocateMemory< T >( _N );
 216         _myMemory = true;
 217         VectorAssignScalar< T >( _vector, data, _N );
 218
 219     }
 220
 221 // -----------------------------------------------------------------------------
 222     template< class T >
 223     TVector< T >::TVector( const TVector< T >& r )
 224     {
 225         _N        = r._N;
 226         _type     = r._type;
 227         _myMemory = true;
 228         _vector   = VectorCopyMemory< T >( r._vector, _N );
 229
 230     }
 231
 232 // -----------------------------------------------------------------------------
 233     template< class T >
 234     TVector< T >::TVector( T* block, uint32_t N, bool copy, int type )
 235     {
 236         _N        = N;
 237         _type     = type;
 238         _myMemory = copy;
 239         _vector   = ( copy )? VectorCopyMemory< T >( block, _N ): block;
 240
 241     }
 242
 243 // -----------------------------------------------------------------------------
 244     template< class T >
 245     void TVector< T >::SetN( uint32_t N )
 246     {
 247         if( _myMemory ) VectorFreeMemory< T >( _vector );
 248         _N        = N;
 249         _vector   = VectorAllocateMemory< T >( _N );
 250         _myMemory = true;
 251         VectorAssignScalar< T >( _vector, ( T )0, _N );
 252
 253     }
 254
 255 // -----------------------------------------------------------------------------
 256     template< class T >
 257     TVector< T >& TVector< T >::operator=( const TVector< T >& r )
 258     {
 259         /*
 260          * Only assigns the minimum cardinality (WARNING WITH NON-LOCAL MEMORY).
 261          */
 262         _type = r._type;
 263         VectorAssignMemory< T >( _vector, r._vector, GTM_MIN( _N, r._N ) );
 264         return( *this );
 265
 266     }
 267
 268 // -----------------------------------------------------------------------------
 269     template< class T >
 270     bool TVector< T >::operator==( const TVector< T >& r )
 271     {
 272         uint32_t i;
 273         bool ret;
 274
 275         for(
 276             i = 0, ret = ( _N == r._N );
 277             i < _N && ret;
 278             ret &= ( _vector[ i ] == r._vector[ i ] ), i++
 279             );
 280         return( ret );
 281
 282     }
 283
 284 // -----------------------------------------------------------------------------
 285     template< class T >
 286     bool TVector< T >::operator!=( const TVector< T >& r )
 287     {
 288         uint32_t i;
 289         bool ret;
 290
 291         for(
 292             i = 0, ret = ( _N != r._N );
 293             i < _N && !ret;
 294             ret |= ( _vector[ i ] != r._vector[ i ] ), i++
 295             );
 296         return( ret );
 297
 298     }
 299
 300 // -----------------------------------------------------------------------------
 301     template< class T >
 302     TVector< T > TVector< T >::operator+( const TVector< T >& r )
 303     {
 304         TVector< T > ret( GTM_MIN( _N, r._N ) );
 305
 306         VectorAdd< T >( ret._vector, _vector, r._vector, GTM_MIN( _N, r._N ) );
 307         return( ret );
 308
 309     }
 310
 311 // -----------------------------------------------------------------------------
 312     template< class T >
 313     TVector< T > TVector< T >::operator-( const TVector< T >& r )
 314     {
 315         TVector< T > ret( GTM_MIN( _N, r._N ) );
 316
 317         VectorSubtract< T >( ret._vector, _vector, r._vector, GTM_MIN( _N, r._N ) );
 318         return( ret );
 319
 320     }
 321
 322 // -----------------------------------------------------------------------------
 323     template< class T >
 324     TVector< T > TVector< T >::operator*( const TVector< T >& r )
 325     {
 326         TVector< T > ret( GTM_MIN( _N, r._N ) );
 327
 328         VectorCrossProduct< T >( ret._vector, _vector, r._vector );
 329         return( ret );
 330
 331     }
 332
 333 // -----------------------------------------------------------------------------
 334     template< class T >
 335     TVector< T > TVector< T >::operator*( T r )
 336     {
 337         TVector< T > ret( _N );
 338
 339         VectorScalarProduct< T >( ret._vector, _vector, r, _N );
 340         return( ret );
 341
 342     }
 343
 344 // -----------------------------------------------------------------------------
 345     template< class T >
 346     TVector< T > TVector< T >::operator-( )
 347     {
 348         TVector< T > ret( _N );
 349         uint32_t i;
 350
 351         for( i = 0; i < _N; ret._vector[ i ] = ( T )0 - _vector[ i ], i++ );
 352         return( ret );
 353
 354     }
 355
 356 // -----------------------------------------------------------------------------
 357     template< class T >
 358     TVector< T > TVector< T >::operator!( )
 359     {
 360         TVector< T > ret( _N );
 361
 362         VectorNormalize< T >( ret._vector, _vector, _N );
 363         return( ret );
 364
 365     }
 366
 367 // -----------------------------------------------------------------------------
 368     template< class T >
 369     TVector< T > TVector< T >::operator~( )
 370     {
 371         TVector< T > ret = *this;
 372
 373         ret._type = ( _type == COL_VECTOR )? ROW_VECTOR: COL_VECTOR;
 374         return( ret );
 375
 376     }
 377
 378 } // namespace
 379
 380 #endif // GTMLIB__MATH__VECTOR__HXX
 381
 382 // EOF - vector.h