Mtx.h

Go to the documentation of this file.

/*****************************************************************************
 $RCSfile: Mtx.h,v $ --- $Date: 2006/07/18 01:45:34 $ --- $Revision: 1.2 $
 *****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #ifndef CALC_MTX_H
 #define CALC_MTX_H

/*****************************************************************************
 INCLUDE FILES
 *****************************************************************************/

 #include <iomanip>

 #include "Base.h"

/*****************************************************************************
 NAMESPACE IDENTIFICATIONS
 *****************************************************************************/

 namespace calc {

/*****************************************************************************
 MtxErr CLASS
 *****************************************************************************/


 class MtxErr:public Err {

 public:

 // Enumerations

    enum ERR_ENUM {
       INIT=0,    
       MEMORY,    
       SINGULAR,  
       ERR_CNT    
    };

 // Constructors

    MtxErr(enum MtxErr::ERR_ENUM indErr):
    Err() {
       const char* const CLASS_NAME="Mtx";
       const char* const ERR_STR[ERR_CNT]={
          "object initialization error",   // text for index INIT
          "memory allocation error",       // text for index MEMORY
          "matrix is singular",            // text for index SINGULAR
       };
       setError(indErr,CLASS_NAME,ERR_STR[indErr]);
    }

 // Data Members

 private:

    static const char* const CLASS_NAME;
    static const char* const ERR_STR[MtxErr::ERR_CNT];
 };

/*****************************************************************************
 Mtx CLASS TEMPLATE
 *****************************************************************************/


 template <typename aType>
 class Mtx:public Base {

 public:

 // Enumerations

    enum VTYPE {
       ROW_DATA=0,       
       COLUMN_DATA,      
       TOTAL_DATA,       
       VTYPE_CNT    
    };

 // Constructors

    Mtx(const aType *array, int nRows, int nCols);
    Mtx(aType var);
    Mtx(const Mtx<aType>& mt);

    Mtx(void):Base() {varInit();}
   ~Mtx(void) {if(aMtx) deleteMem(aMtx);}

 // Member Functions

    aType            high        (void) const;
    aType            low         (void) const;
    aType            average     (void) const;
    aType            absolute    (void) const;
    aType            determinant (void) const throw (MtxErr);
    aType           *copyArray   (aType *array) const;
    Mtx<aType>       operator!   (void) const throw (MtxErr);
    Mtx<aType>       operator~   (void) const;
    Mtx<aType>       operator*   (const Mtx<aType>& mt) const;
    const Mtx<aType> operator=   (const Mtx<aType>& mt);
    const Mtx<aType> operator=   (aType x);
    bool             operator==  (const Mtx<aType>& mt) const;
    bool             operator!=  (const Mtx<aType>& mt) const;

 // Get Data Functions

    int getCount(enum Mtx<aType>::VTYPE vType) const
       {return ((!nogo)&&(vType>=0)&&(vType<VTYPE_CNT)?nCount[vType]:-1);}

 // Conversion Functions

    operator const aType* (void) const {return (nogo?(aType*)(0):aMtx[0]);}
    operator const aType* const* (void) const {return (nogo?(aType**)(0):aMtx);}

 // Addition Functions

    Mtx<aType> operator+(void) const {return Mtx<aType>(*this);}
    Mtx<aType> operator+(const Mtx<aType>& mt) const {return sumMtx(mt,1);}
    Mtx<aType> operator+=(const Mtx<aType>& mt) {return sumEqMtx(mt,1);}

 // Subtraction Functions

    Mtx<aType> operator-(void) const {return prdMtx((aType)(-1));}
    Mtx<aType> operator-(const Mtx<aType>& mt) const {return sumMtx(mt,-1);}
    const Mtx<aType> operator-=(const Mtx<aType>& mt) {return sumEqMtx(mt,-1);}

 // Multiplication and Division Functions

    Mtx<aType> operator*(aType scalar) const
       {return prdMtx(scalar);}
    Mtx<aType> operator/(aType scalar) const
       {return prdMtx((aType)(1)/scalar);}
    const Mtx<aType> operator*=(aType scalar) {return prdEqMtx(scalar);}
    const Mtx<aType> operator/=(aType scalar) {return prdEqMtx((aType)(1)/scalar);}

 // Related Output Functions

    template <typename bType>
    friend std::ostream& operator<<(std::ostream& ostr, const Mtx<bType>& mt)
       {return mt.outMtx(ostr);}

 // Related Mathematical Functions

    template <typename bType>
    friend Mtx<bType> operator*(bType scalar, const Mtx<bType>& mt)
       {return mt.prdMtx(scalar);}
    template <typename bType>
    friend bType fabs(const Mtx<bType>& mt)
       {return mt.absolute();}

    static const int DEF_PRINT_WIDTH;

 private:

 // Member Functions

    virtual void  varInit       (void);

    aType       **newMem        (int nRows, int nCols) const;
    void          deleteMem     (aType **ar) const;
    bool          adjustMtx     (int nRows, int nCols);
    std::ostream& outMtx        (std::ostream& ostr) const;
    Mtx<aType>    sumMtx        (const Mtx<aType>& mt, int sign) const;
    Mtx<aType>    prdMtx        (aType scalar) const;

    const Mtx<aType>  sumEqMtx  (const Mtx<aType>& mt, int sign);
    const Mtx<aType>  prdEqMtx  (aType scalar);

    bool varAlloc(int nRows, int nCols)
       {return (!(aMtx=newMem(nRows,nCols)));}

 // Data Members

    aType **aMtx;               
    int     nCount[VTYPE_CNT];  
 };}

/*****************************************************************************/

 template <typename aType>
 const int calc::Mtx<aType>::DEF_PRINT_WIDTH=14;

/*****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #endif

/*****************************************************************************
 CLASS TEMPLATE SOURCE
 *****************************************************************************/

 #include "Mtx.cpp"

/*****************************************************************************/

---