matrix.h

Go to the documentation of this file.

// matrix.h
// Creation : 19/03/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__MATRIX__HXX
#define GTMLIB__MATH__MATRIX__HXX

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

namespace gtm
{
    template< class T >
    class TMatrix
    {
    public:
        

        TMatrix( uint N = 3, uint M = 3, T data = ( T )0 );
        TMatrix( const TMatrix< T >& r );
        TMatrix( T** block, uint N, uint M );

        ~TMatrix( ) {
            MatrixFreeMemory< T >( _matrix, _N );
        };


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

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

        T& operator()( uint i, uint j ) {
            return( _matrix[ i ][ j ] );
        };
        uint GetN( ) {
            return( _N );
        };
        uint GetM( ) {
            return( _M );
        };
        T** GetAnsiRef( ) {
            return( _matrix );
        };
        T Det( ) {
            return( MatrixDeterminant< T >( _matrix, _N ) );
        };
        void LoadIdentity( ) {
            MatrixLoadIdentity< T >( _matrix, GTM_MIN( _N, _M ) );
        };


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


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


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

    private:



        T** _matrix;
        uint _N;
        uint _M;

    };

// -----------------------------------------------------------------------------
    template< class T >
    TVector< T >& TVector< T >::operator=( TMatrix< T >& r )
    {
        uint i, j, k, min;

        // This min calc. avoids to reserve temporary memory, so, be careful.
        min = GTM_MIN( r.GetN( ) * r.GetM( ), _N );
        _type = ( r.GetN( ) == 1 )? COL_VECTOR: ROW_VECTOR;
        for( i = 0, k = 0; i < r.GetN( ) && k < min; i++ )
            for( j = 0; j < r.GetM( ) && k < min; _vector[ k++ ] = r( i, j ), j++ );
        return( *this );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TVector< T >::operator*( TMatrix< T >& r )
    {
        TMatrix< T > m = *this;
        return( m * r );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >::TMatrix( uint N, uint M, T data )
    {
        _N = N;
        _M = M;
        _matrix = MatrixAllocateMemory< T >( _N, _M );
        MatrixAssignScalar< T >( _matrix, data, _N, _M );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >::TMatrix( const TMatrix< T >& r )
    {
        _N = r._N;
        _M = r._M;
        _matrix = MatrixCopyMemory< T >( r._matrix, _N, _M );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >::TMatrix( T** block, uint N, uint M )
    {
        _N = N;
        _M = M;
        _matrix = MatrixCopyMemory< T >( block, N, M );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >& TMatrix< T >::operator=( const TMatrix< T >& r )
    {
        if( _N != r._N || _M != r._M ) {

            MatrixFreeMemory< T >( _matrix, _N );
            _N = r._N;
            _M = r._M;
            _matrix = MatrixCopyMemory< T >( r._matrix, _N, _M );

        } else MatrixAssignMemory< T >( _matrix, r._matrix, _N, _M );
        return( *this );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >& TMatrix< T >::operator=( TVector< T >& r )
    {
        uint i;
        uint n = r.GetN( );
        bool column = ( r.GetType( ) == COL_VECTOR );

        MatrixFreeMemory< T >( _matrix, _N );
        _N = ( column )? 1: n;
        _M = ( column )? n: 1;
        _matrix = MatrixAllocateMemory< T >( _N, _M );
        for( i = 0; i < n; _matrix[ ( column )? 0: i ][ ( column )? i: 0 ] = r( i ), i++ );
        return( *this );
  
    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T >& TMatrix< T >::operator=( T r )
    {
        MatrixAssignScalar< T >( _matrix, r, _N, _M );
        return( *this );

    }

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

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

    }

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

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

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator+( const TMatrix< T >& r )
    {
        TMatrix< T > ret( _N, _M );

        MatrixAdd< T >(
            ret._matrix,
            _matrix,
            r._matrix,
            GTM_MIN( _N, r._N ),
            GTM_MIN( _M, r._M )
            );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator-( const TMatrix< T >& r )
    {
        TMatrix< T > ret( _N, _M );
  
        MatrixSubtract< T >(
            ret._matrix,
            _matrix,
            r._matrix,
            GTM_MIN( _N, r._N ),
            GTM_MIN( _M, r._M )
            );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator*( const TMatrix< T >& r )
    {
        TMatrix< T > ret( r._N, _M );

        MatrixProduct< T >( ret._matrix, _matrix, r._matrix, _N, _M, r._N );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator*( T r )
    {
        TMatrix< T > ret( _N, _M );

        MatrixScalarProduct< T >( ret._matrix, _matrix, r, _N, _M );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator*( TVector< T >& r )
    {
        TMatrix< T > m;
        m = r;
        return( *this * m );

    }

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

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator!( )
    {
        TMatrix< T > ret( _N, _N );

        if( _N <= 4 ) MatrixInverseAdjoint< T >( ret._matrix, _matrix, _N );
        else          MatrixInverseGauss< T >( ret._matrix, _matrix, _N );
        return( ret );

    }

// -----------------------------------------------------------------------------
    template< class T >
    TMatrix< T > TMatrix< T >::operator~( )
    {
        TMatrix< T > ret( _M, _N );

        MatrixTranspose< T >( ret._matrix, _matrix, _N, _M );
        return( ret );

    }

} // namespace

#endif // GTMLIB__MATH__MATRIX__HXX

// EOF - matrix.h

---