vector.h

Go to the documentation of this file.

// vector.h
// Creation : 24/02/2000
// Author   : Leonardo FLOREZ VALENCIA
//               l-florez@uniandes.edu.co
//               lflorez@creatis.insa-lyon.fr
// Copyright (C) 2000-2002 Leonardo FLOREZ VALENCIA
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef GTMLIB__MATH__VECTOR__HXX
#define GTMLIB__MATH__VECTOR__HXX

#include "mathdefs.h"
#include "vmfuncs.h"


#define ROW_VECTOR 0x01
#define COL_VECTOR 0x02


namespace gtm
{
    template< class T >
    class TMatrix;

    template< class T >
    class TVector
    {
    public:


        TVector( uint N = 3, T data = ( T )0, int type = COL_VECTOR  );
        TVector( const TVector< T >& r );
        TVector( T* block, uint N, bool copy = true, int type = COL_VECTOR );

        ~TVector( ) {
            if( _myMemory ) VectorFreeMemory< T >( _vector );
        };

        void SetN( uint N );


        TVector< T >& operator=( const TVector< T >& r );
        TVector< T >& operator=( TMatrix< T >& r );
        TVector< T >& operator=( T* r ) {
            VectorAssignMemory< T >( _vector, r, _N );
            return( *this );
        };
        TVector< T >& operator=( T r ) {
            VectorAssignScalar< T >( _vector, r, _N );
            return( *this );
        };


        bool operator==( const TVector< T >& r );
        bool operator!=( const TVector< T >& r );

        T& operator()( uint i ) {
            return( _vector[ i ] );
        };
        T* GetAnsiRef( ) {
            return( _vector );
        };
        uint GetN( ) {
            return( _N );
        };
        int GetType( ) {
            return( _type );
        };
        T GetNorm( ) {
            return( VectorNorm< T >( _vector, _N ) );
        };
        void Normalize( ) {
            VectorNormalize< T >( _vector, _vector, _N );
        };
        T Dot( const TVector< T >& r ) {
            return( VectorDotProduct< T >( _vector, r._vector, GTM_MIN( _N, r._N ) ) );
        };


        TVector< T > operator+( const TVector< T >& r );
        TVector< T > operator-( const TVector< T >& r );
        TVector< T > operator*( const TVector< T >& r );
        TMatrix< T > operator*( TMatrix< T >& r );
        TVector< T > operator*( T r );


        TVector< T >& operator+=( const TVector< T >& r ) {
            *this = *this + r;
            return( *this );
        };
        TVector< T >& operator-=( const TVector< T >& r ) {
            *this = *this - r;
            return( *this );
        };
        TVector< T >& operator*=( const TVector< T >& r ) {
            *this = *this * r;
            return( *this );
        };
        TVector< T >& operator*=( T r ) {
            *this = *this * r;
            return( *this );
        };



        TVector< T > operator-( );
        TVector< T > operator!( );
        TVector< T > operator~( );

    private:



        T* _vector;
        uint _N;
        int _type;
        bool _myMemory;

    };

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T >::TVector( uint N, T data, int type )
    {
        _N        = N;
        _type     = type;
        _vector   = VectorAllocateMemory< T >( _N );
        _myMemory = true;
        VectorAssignScalar< T >( _vector, data, _N );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T >::TVector( const TVector< T >& r )
    {
        _N        = r._N;
        _type     = r._type;
        _myMemory = true;
        _vector   = VectorCopyMemory< T >( r._vector, _N );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T >::TVector( T* block, uint N, bool copy, int type )
    {
        _N        = N;
        _type     = type;
        _myMemory = copy;
        _vector   = ( copy )? VectorCopyMemory< T >( block, _N ): block;

    }

// -----------------------------------------------------------------------------
    template< class T >
    void TVector< T >::SetN( uint N )
    {
        if( _myMemory ) VectorFreeMemory< T >( _vector );
        _N        = N;
        _vector   = VectorAllocateMemory< T >( _N );
        _myMemory = true;
        VectorAssignScalar< T >( _vector, ( T )0, _N );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T >& TVector< T >::operator=( const TVector< T >& r )
    {
        /*
         * Only assigns the minimum cardinality (WARNING WITH NON-LOCAL MEMORY).
         */
        _type = r._type;
        VectorAssignMemory< T >( _vector, r._vector, GTM_MIN( _N, r._N ) );
        return( *this );

    }

// -----------------------------------------------------------------------------
    template< class T >
    bool TVector< T >::operator==( const TVector< T >& r )
    {
        uint i;
        bool ret;

        for(
            i = 0, ret = ( _N == r._N );
            i < _N && ret;
            ret &= ( _vector[ i ] == r._vector[ i ] ), i++
            );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    bool TVector< T >::operator!=( const TVector< T >& r )
    {
        uint i;
        bool ret;

        for(
            i = 0, ret = ( _N != r._N );
            i < _N && !ret;
            ret |= ( _vector[ i ] != r._vector[ i ] ), i++
            );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator+( const TVector< T >& r )
    {
        TVector< T > ret( GTM_MIN( _N, r._N ) );
  
        VectorAdd< T >( ret._vector, _vector, r._vector, GTM_MIN( _N, r._N ) );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator-( const TVector< T >& r )
    {
        TVector< T > ret( GTM_MIN( _N, r._N ) );
  
        VectorSubtract< T >( ret._vector, _vector, r._vector, GTM_MIN( _N, r._N ) );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator*( const TVector< T >& r )
    {
        TVector< T > ret( GTM_MIN( _N, r._N ) );
  
        VectorCrossProduct< T >( ret._vector, _vector, r._vector );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator*( T r )
    {
        TVector< T > ret( _N );
  
        VectorScalarProduct< T >( ret._vector, _vector, r, _N );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator-( )
    {
        TVector< T > ret( _N );
        uint i;
  
        for( i = 0; i < _N; ret._vector[ i ] = ( T )0 - _vector[ i ], i++ );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator!( )
    {
        TVector< T > ret( _N );
  
        VectorNormalize< T >( ret._vector, _vector, _N );
        return( ret );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T > TVector< T >::operator~( )
    {
        TVector< T > ret = *this;
  
        ret._type = ( _type == COL_VECTOR )? ROW_VECTOR: COL_VECTOR;
        return( ret );
  
    }

} // namespace

#endif // GTMLIB__MATH__VECTOR__HXX

// EOF - vector.h