Changeset 804 in Sophya for trunk/SophyaLib/TArray/tmatrix.h


Ignore:
Timestamp:
Apr 3, 2000, 7:36:01 PM (25 years ago)
Author:
ansari
Message:

Amelioation / debugging de la classe TArray<T> - TVector et TMatrix

heritent maintenant de TArray<T> - Classe RCMatrix rendu prive au fichier
sopemtx.cc - linfit.cc integre a sopemtx.cc

Reza 03/04/2000

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/TArray/tmatrix.h

    r772 r804  
    55
    66#include "machdefs.h"
    7 #include <stdio.h>
    8 #include <iostream.h>
    9 #include <complex>
    10 #include "ppersist.h"
    11 #include "anydataobj.h"
    12 #include "ndatablock.h"
     7#include "tarray.h"
    138
    149namespace SOPHYA {
    1510
    1611template <class T>
    17 class TMatrix : public AnyDataObj {
     12class TMatrix : public TArray<T> {
    1813public:
    19 
    2014  // Creation / destruction
    2115  TMatrix();
    22   TMatrix(uint_4 r,uint_4 c);
    23   TMatrix(uint_4 r,uint_4 c,T* values,Bridge* br=NULL);
     16  TMatrix(uint_4 r,uint_4 c, short mm=AutoMemoryMapping);
    2417  TMatrix(const TMatrix<T>& a);
    25   TMatrix(const TMatrix<T>& a,bool share);
     18  TMatrix(const TMatrix<T>& a, bool share);
     19  TMatrix(const TArray<T>& a);
     20  TMatrix(const TArray<T>& a,  bool share, short mm=CMemoryMapping);
    2621  virtual ~TMatrix();
    2722
    28   // Temporaire?
    29   inline bool IsTemp(void) const {return mNDBlock.IsTemp();}
    30   inline void SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
     23  //  Pour verifiez la compatibilite de dimensions lors de l'affectation
     24  virtual TArray<T>& Set(const TArray<T>& a);
     25  inline  TMatrix<T>& operator = (const TMatrix<T>& a)
     26                       { Set(a);  return(*this); }
    3127
    32   // Gestion taille/Remplissage
    33   inline void Clone(const TMatrix<T>& a)  // Clone: copie des donnees de "a"
    34               {mNDBlock.Clone(a.mNDBlock); mNr = a.mNr; mNc = a.mNc;}
    35   inline void Reset(T v=0) {mNDBlock.Reset(v);}
    36   inline void ReSize(uint_4 r,uint_4 c)  // Reallocation de place
    37        {if(r==0||c==0) throw(SzMismatchError("TMatrix::ReSize r ou c==0\n"));
    38         mNDBlock.ReSize(r*c); mNr = r; mNc = c;}
    39   inline void Realloc(uint_4 r,uint_4 c,bool force=false)
    40        {if(r==0||c==0) throw(SzMismatchError("TMatrix::Realloc r ou c==0\n"));
    41         mNDBlock.Realloc(r*c,force); mNr = r; mNc = c;}
     28  // Size - Changing the Size
     29  inline uint_4 NRows() const {return Size(marowi_); }
     30  inline uint_4 NCols() const {return Size(macoli_); }
     31  inline uint_4 NCol()  const {return Size(macoli_); } // back-compat Peida
    4232
    43   // Informations pointeur/data
    44   inline uint_4 NRows() const {return mNr;}
    45   inline uint_4 NCols() const {return mNc;}
    46   inline uint_4 NCol() const {return mNc;} // back-compat Peida
    47   inline T const& operator()(uint_4 r,uint_4 c) const
    48                             {return *(mNDBlock.Begin()+r*mNc+c);}
    49   inline T&       operator()(uint_4 r,uint_4 c)
    50                             {return *(mNDBlock.Begin()+r*mNc+c);}
    51   inline T const& operator[](uint_4 ip) const
    52                             {return *(mNDBlock.Begin()+ip);}
    53   inline T&       operator[](uint_4 ip)
    54                             {return *(mNDBlock.Begin()+ip);}
    55   inline       T* Data()       {return mNDBlock.Begin();}
    56   inline const T* Data() const {return mNDBlock.Begin();}
    57   inline       NDataBlock<T>& DataBlock()       {return mNDBlock;}
    58   inline const NDataBlock<T>& DataBlock() const {return mNDBlock;}
     33  void ReSize(uint_4 r,uint_4 c, short mm=SameMemoryMapping);  // Reallocation de place
     34  void Realloc(uint_4 r,uint_4 c, short mm=SameMemoryMapping, bool force=false);
     35
     36  // Sub-matrix extraction $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
     37  TMatrix<T> operator () (Range rline, Range rcol) const ;
     38
     39  // Inline element acces methods
     40  inline T const& operator()(uint_4 r,uint_4 c) const;
     41  inline T&       operator()(uint_4 r,uint_4 c);
    5942
    6043  // Operations matricielles
    61   TMatrix<T> Transpose(void) const;
     44  TMatrix<T>& Transpose();
     45  //mm = SameMemoryMapping or CMemoryMapping or FortranMemoryMapping
     46  TMatrix<T>  Transpose(short mm);
     47  // Rearranging Matrix Elements
     48  TMatrix<T>  Rearrange(short mm);
    6249
    6350  // Operateur d'affectation
    64   // A = x (matrice diagonale x*Identite)
    65   inline TMatrix<T>& operator = (T x)
    66     {if(mNr!=mNc || mNr==0) throw(SzMismatchError("TMatrix::operator= mNc!=mNr ou ==0\n"));
    67      for(uint_4 r=0;r<mNr;r++) for(uint_4 c=0;c<mNc;c++) (*this)(r,c)=(r==c)?x:(T)0;
    68      return *this;}
    69   // A = B : partage les donnees si "a" est temporaire, clone sinon.
    70   inline TMatrix<T>& operator = (const TMatrix<T>& a)
    71                 {if(this == &a) return *this; CloneOrShare(a); return *this;}
     51  // A = x (matrice diagonale Identite)
     52  virtual TMatrix<T>& SetIdentity(IdentityMatrix imx);
     53  inline  TMatrix<T>& operator = (IdentityMatrix imx) { return SetIdentity(imx); }
    7254
    73   // Impression
    74   void Print(ostream& os,int lp=0,uint_4 i0=0,uint_4 ni=10,uint_4 j0=0,uint_4 nj=10) const;
    75   inline void Print(int lp=0,uint_4 i0=0,uint_4 ni=10,uint_4 j0=0,uint_4 nj=10) const
    76               {Print(cout,lp,i0,ni,j0,nj);}
     55  // Operations diverses  avec une constante
     56  inline  TMatrix<T>&  operator = (T x)             { Set(x); return(*this); }
     57  inline  TMatrix<T>&  operator += (T x)            { Add(x); return(*this); }
     58  inline  TMatrix<T>&  operator -= (T x)            { Sub(x); return(*this); }
     59  inline  TMatrix<T>&  operator *= (T x)            { Mul(x); return(*this); }
     60  inline  TMatrix<T>&  operator /= (T x)            { Div(x); return(*this); }
    7761
    78   // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) (T) x
    79   inline TMatrix<T>& operator += (T b) {mNDBlock += b; return *this;}
    80   inline TMatrix<T>& operator -= (T b) {mNDBlock -= b; return *this;}
    81   inline TMatrix<T>& operator *= (T b) {mNDBlock *= b; return *this;}
    82   inline TMatrix<T>& operator /= (T b) {mNDBlock /= b; return *this;}
     62  //  operations avec matrices
     63  inline  TMatrix<T>&  operator += (const TMatrix<T>& a)  { return AddElt(a); }
     64  inline  TMatrix<T>&  operator -= (const TMatrix<T>& a)  { return SubElt(a); }
    8365
    84   // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) B
    85   inline TMatrix<T>& operator += (const TMatrix<T>& a)
    86               {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
    87                   throw(SzMismatchError("TMatrix::operator+=A size mismatch"));
    88                mNDBlock += a.mNDBlock; return *this;}
    89   inline TMatrix<T>& operator -= (const TMatrix<T>& a)
    90               {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
    91                   throw(SzMismatchError("TMatrix::operator-=A size mismatch"));
    92                mNDBlock -= a.mNDBlock; return *this;}
    93   TMatrix<T>& operator *= (const TMatrix<T>& a);
     66  // Input-Output
     67  virtual void  Print(ostream& os, int_4 maxprt=-1, bool si=false) const ;
    9468
    95   // Pour surcharge d'operateurs C = A (+,-,*) B
    96   TMatrix<T> Add(const TMatrix<T>& b) const;
    97   TMatrix<T> Sub(const TMatrix<T>& b) const;
    98   TMatrix<T> Mul(const TMatrix<T>& b) const;
     69  // Produit matriciel
     70  TMatrix<T>  Multiply(const TMatrix<T>& b, short mm=SameMemoryMapping) const;
     71  //  inline TMatrix<T>& operator *= (const TMatrix<T>& b)
     72
     73protected:
     74};
     75
     76//  ---- inline acces methods ------
     77template <class T>
     78inline T const& TMatrix<T>::operator()(uint_4 r, uint_4 c) const
     79{
     80#ifdef SO_BOUNDCHECKING
     81  if (marowi_ == 0)   CheckBound(r, c, 0, 0, 0, 4);
     82  else   CheckBound(c, r, 0, 0, 0, 4);
     83#endif
     84  return ( *( mNDBlock.Begin()+ offset_+
     85              r*step_[marowi_] + c*step_[macoli_] ) );
     86}
     87
     88template <class T>
     89inline T & TMatrix<T>::operator()(uint_4 r, uint_4 c)
     90{
     91#ifdef SO_BOUNDCHECKING
     92  if (marowi_ == 0)   CheckBound(r, c, 0, 0, 0, 4);
     93  else   CheckBound(c, r, 0, 0, 0, 4);
     94#endif
     95  return ( *( mNDBlock.Begin()+ offset_+
     96              r*step_[marowi_] + c*step_[macoli_] ) );
     97}
    9998
    10099
    101 protected:
    102   // partage les donnees si "a" temporaire, clone sinon.
    103   inline void CloneOrShare(const TMatrix<T>& a)
    104               {mNDBlock.CloneOrShare(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
    105   // Share: partage les donnees de "a"
    106   inline void Share(const TMatrix<T>& a)
    107               {mNDBlock.Share(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
     100// Surcharge d'operateurs C = A * B
    108101
    109   uint_4 mNr,mNc;
    110   NDataBlock<T> mNDBlock;
    111 };
     102template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, const TMatrix<T>& b)
     103{ TMatrix<T> result(a); result.SetTemp(true); result.Multiply(b);  return result;}
    112104
    113 ////////////////////////////////////////////////////////////////
    114 // Impression
    115 
    116 template <class T>
    117 inline ostream& operator << (ostream& os, const TMatrix<T>& a)
    118                             {a.Print(os); return(os);}
    119 
    120 ////////////////////////////////////////////////////////////////
    121 // Surcharge d'operateurs A (+,-,*,/) (T) x
    122 
    123 template <class T> inline TMatrix<T> operator + (const TMatrix<T>& a, T b)
    124     {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
    125 
    126 template <class T> inline TMatrix<T> operator + (T b,const TMatrix<T>& a)
    127     {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
    128 
    129 template <class T> inline TMatrix<T> operator - (const TMatrix<T>& a, T b)
    130     {TMatrix<T> result(a); result.SetTemp(true); result -= b; return result;}
    131 
    132 template <class T> inline TMatrix<T> operator - (T b,const TMatrix<T>& a)
    133     {TMatrix<T> result(a); result.SetTemp(true);
    134      result.DataBlock() = b-result.DataBlock(); return result;}
    135 
    136 template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, T b)
    137     {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
    138 
    139 template <class T> inline TMatrix<T> operator * (T b,const TMatrix<T>& a)
    140     {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
    141 
    142 template <class T> inline TMatrix<T> operator / (const TMatrix<T>& a, T b)
    143     {TMatrix<T> result(a); result.SetTemp(true); result /= b; return result;}
    144 
    145 ////////////////////////////////////////////////////////////////
    146 // Surcharge d'operateurs C = A (+,-,*,/) B
    147 
    148 template <class T>
    149 inline TMatrix<T> operator + (const TMatrix<T>& a,const TMatrix<T>& b)
    150                   {return a.Add(b);}
    151 
    152 template <class T>
    153 inline TMatrix<T> operator - (const TMatrix<T>& a,const TMatrix<T>& b)
    154                   {return a.Sub(b);}
    155 
    156 template <class T>
    157 inline TMatrix<T> operator * (const TMatrix<T>& a,const TMatrix<T>& b)
    158                   {return a.Mul(b);}
    159 
    160 ////////////////////////////////////////////////////////////////
    161 // Typedef pour simplifier et compatibilite Peida
    162105typedef TMatrix<r_8> Matrix;
    163 
    164 /////////////////////////////////////////////////////////////////////////
    165 // Classe pour la gestion de persistance
    166 template <class T>
    167 class FIO_TMatrix : public  PPersist  {
    168 public:
    169   FIO_TMatrix();
    170   FIO_TMatrix(string const & filename);
    171   FIO_TMatrix(const TMatrix<T> & obj);
    172   FIO_TMatrix(TMatrix<T> * obj);
    173   virtual ~FIO_TMatrix();
    174   virtual AnyDataObj* DataObj();
    175   virtual void        SetDataObj(AnyDataObj & o);
    176   inline operator TMatrix<T>() { return(*dobj); }
    177 protected :
    178   virtual void ReadSelf(PInPersist&);           
    179   virtual void WriteSelf(POutPersist&) const; 
    180   TMatrix<T> * dobj;
    181   bool ownobj;
    182 };
    183 
    184 template <class T>
    185 inline POutPersist& operator << (POutPersist& os, TMatrix<T> & obj)
    186 { FIO_TMatrix<T> fio(&obj);  fio.Write(os);  return(os); }
    187 template <class T>
    188 inline PInPersist& operator >> (PInPersist& is, TMatrix<T> & obj)
    189 { FIO_TMatrix<T> fio(&obj);  fio.Read(is);  return(is); }
    190 
    191106
    192107} // Fin du namespace
Note: See TracChangeset for help on using the changeset viewer.