GMatrixT.hh

Go to the documentation of this file.

//======================================================================
/*! \file GMatrixT.hh
 *
 *  Include file for a template matrix class.
 */
//======================================================================

#ifndef G_MATRIX_T_HH
#define G_MATRIX_T_HH

#include "GGlobal.hh"
#include "GLogMessage.hh"
#include "GBaseFunctions.hh"
#include "GStringFunctions.hh"

template <typename T> class GVectorT;

//======================================================================

/*! Template class defining a matrix for numerical types
 *
 *  The basic matrix operations are defined, with the assumption that
 *  the standard algebaric operation of the template class are defined.
 *
 *  For effective instantiation of a class, the following functions
 *  should be specialised (see file GMatrixD.hh):
 *  - (none)
 *
 *  \note
 *  - the initialisation functions InitElement and InitData clear the
 *    elements memory with 0; if elements initialisation requires
 *    more sophisticated actions, due to class type, the template
 *    class must be derived.
 */
template <typename T> class GMatrixT
{
  //----------------------------------------------------------
  GObject(GMatrixT<T>)
  //----------------------------------------------------------

  protected:
    bool    change_dim;   ///< Indicates if dimensions can be changed
    size_t  nb_row;       ///< Rows number
    size_t  nb_col;       ///< Columns number
    size_t  dimension;    ///< Total dimension
    T     * element;      ///< Elements array

  public:
  //----------------------------------------------------------
  // Constructors / Affectation / Destructor

    GMatrixT<T> ( size_t nr = 1, size_t nc = 1 );
    GMatrixT<T> ( size_t nr, size_t nc, const T & x );
    GMatrixT<T> ( const GMatrixT<T> & m );

    GMatrixT<T> & operator = ( const GMatrixT<T> & m );

    virtual ~GMatrixT<T> ( );

  protected:

  //----------------------------------------------------------
  // Initialisation functions

    virtual T *   Allocate ( size_t nr, size_t nc );
    virtual void  Reset ( );

  public:
    virtual void  InitElement ( size_t i );
    virtual void  InitData ( );
    virtual void  InitData ( const T x );
    virtual void  InitData ( const T x[] );

  //----------------------------------------------------------
  // Check functions
    virtual bool CheckIndex      ( size_t i, size_t j ) const;
    virtual bool CheckIndex      ( size_t k ) const;
    virtual bool CheckDimensions ( const GMatrixT<T> & m ) const;
    virtual bool CheckProduct    ( const GMatrixT<T> & m ) const;
    virtual bool CheckProduct    ( const GVectorT<T> & v ) const;
    virtual bool CheckDimChange  ( ) const;

  //----------------------------------------------------------

    size_t GetRowsNumber    ( ) const;
    size_t GetColumnsNumber ( ) const;
    size_t GetDimension ( ) const;
    size_t SetDimension ( size_t nr, size_t nc );

    // Return the data array pointer.
    const T * Data ( ) const;
          T * Data ( );

  //----------------------------------------------------------
  // Functions to get components

    size_t  GetIndex ( size_t i, size_t j ) const;

    virtual const T & operator () ( size_t i, size_t j ) const;
    virtual       T & operator () ( size_t i, size_t j );

    GVectorT<T> GetRow    ( size_t i );
    GVectorT<T> GetColumn ( size_t j );

    virtual const T & operator [] ( size_t k ) const;
    virtual       T & operator [] ( size_t k );

  //----------------------------------------------------------
    virtual void SetRow    ( size_t i, const GVectorT<T> & v );
    virtual void SetColumn ( size_t j, const GVectorT<T> & v );

  //----------------------------------------------------------
  // Algebra

    // Addition / subtraction, scaling.
    virtual GMatrixT<T> operator + ( const GMatrixT<T> & m ) const;
    virtual GMatrixT<T> operator - ( const GMatrixT<T> & m ) const;
    virtual GMatrixT<T> operator * ( const T k ) const;
    virtual GMatrixT<T> operator / ( const T k ) const;

    virtual GMatrixT<T> & operator += ( const GMatrixT<T> & m );
    virtual GMatrixT<T> & operator -= ( const GMatrixT<T> & m );
    virtual GMatrixT<T> & operator *= ( const T k );
    virtual GMatrixT<T> & operator /= ( const T k );

    // Unary minus.
    virtual GMatrixT<T> operator - ( ) const;

    // Matrices product.
    virtual GMatrixT<T> operator * ( const GMatrixT<T> & m ) const;
    virtual GVectorT<T> operator * ( const GVectorT<T> & v ) const;

    // Transposition.
    virtual GMatrixT<T> & Transpose ( );
    virtual GMatrixT<T>   GetTransposed ( ) const;

};


//======================================================================
// Related functions

template <typename T> GMatrixT<T> operator * ( const double k, const GMatrixT<T> & m );


//======================================================================
// required for template functions code
#include "GVectorT.hh"

//----------------------------------------------------------------------
// Inline and template functions
#include "icc/GMatrixT.icc"


//======================================================================
#endif