GVectorT.hh

Go to the documentation of this file.

//======================================================================
/*! \file GVectorT.hh
 *
 *  Include file for a template vector class.
 */
//======================================================================

#ifndef G_VECTOR_T_HH
#define G_VECTOR_T_HH

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

template <typename T> class GMatrixT;

//======================================================================
/*! Template class defining a vector for numerical types.
 *
 *  The basic vector 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 GVectorD.hh):
 *  - Norm2: it is well defined for real numbers, but should be precised
 *           for other types
 *
 *  \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 specialised.
 */
template <typename T> class GVectorT
{
  //----------------------------------------------------------
  GObject(GVectorT<T>)
  //----------------------------------------------------------

  static  string  vect_open;    ///< Pattern for string representation
  static  string  vect_close;   ///< Pattern for string representation
  static  string  vect_separ;   ///< Pattern for string representation
  static  string  vect_format;  ///< Pattern for string representation


  protected:
    bool    change_dim;     ///< Indicates if dimension can be changed
    size_t  dimension;      ///< Vector dimension
    T     * element;        ///< Vector elements array

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

    GVectorT ( size_t n = 1 );
    GVectorT ( size_t n, const T & x );
    GVectorT ( size_t n, const T x[] );
    GVectorT ( const GVectorT<T> & v );

    GVectorT & operator = ( const GVectorT<T> & v );

    virtual ~GVectorT ( );  // inline

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

  protected:
    virtual T *   Allocate ( size_t n );
    virtual void  Reset ( );            // inline

  public:

    virtual void InitElement ( size_t i );            // inline
    virtual void InitData ( );                        // inline
    virtual void InitData ( const T x );              // inline
    virtual void InitData ( const T x[] );            // inline
    virtual void InitData ( size_t n, const T x[] );  // inline

  //----------------------------------------------------------
  // Check functions

    virtual bool CheckIndex     ( size_t i ) const;               // inline
    virtual bool CheckDimension ( const GVectorT<T> & v ) const;  // inline
    virtual bool CheckProduct   ( const GMatrixT<T> & m ) const;  // inline

  //----------------------------------------------------------
    size_t SetDimension ( size_t n );
    size_t GetDimension ( ) const;    // inline
    const T * Data ( ) const;         // inline
          T * Data ( );               // inline

  //----------------------------------------------------------
  // Functions to get components
    virtual const T & operator () ( size_t i ) const;
    virtual       T & operator () ( size_t i );
    virtual const T & operator [] ( size_t i ) const;
    virtual       T & operator [] ( size_t i );


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

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

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

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

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

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

  //----------------------------------------------------------
    virtual double Norm2Squared ( ) const;    // inline
    virtual double Norm2 ( ) const;           // inline
    virtual double LengthSquared ( ) const;   // inline
    virtual double Length ( ) const;          // inline

  //----------------------------------------------------------
    virtual string  GetString ( ) const;      // inline
    virtual string  GetString ( const char * fmt ) const;
};


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

/*! Multiplication scaling.
 *  \param  k   scaling factor
 *  \param  v   vector to scale
 */
template <typename T> GVectorT<T> operator * ( const double k, const GVectorT<T> & v );


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

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


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