Index: trunk/SophyaLib/TArray/tmatrix.h
===================================================================
--- trunk/SophyaLib/TArray/tmatrix.h	(revision 772)
+++ trunk/SophyaLib/TArray/tmatrix.h	(revision 804)
@@ -5,188 +5,103 @@
 
 #include "machdefs.h"
-#include <stdio.h>
-#include <iostream.h>
-#include <complex>
-#include "ppersist.h"
-#include "anydataobj.h"
-#include "ndatablock.h"
+#include "tarray.h"
 
 namespace SOPHYA {
 
 template <class T>
-class TMatrix : public AnyDataObj {
+class TMatrix : public TArray<T> {
 public:
-
   // Creation / destruction 
   TMatrix();
-  TMatrix(uint_4 r,uint_4 c);
-  TMatrix(uint_4 r,uint_4 c,T* values,Bridge* br=NULL);
+  TMatrix(uint_4 r,uint_4 c, short mm=AutoMemoryMapping);
   TMatrix(const TMatrix<T>& a);
-  TMatrix(const TMatrix<T>& a,bool share);
+  TMatrix(const TMatrix<T>& a, bool share);
+  TMatrix(const TArray<T>& a); 
+  TMatrix(const TArray<T>& a,  bool share, short mm=CMemoryMapping);
   virtual ~TMatrix();
 
-  // Temporaire?
-  inline bool IsTemp(void) const {return mNDBlock.IsTemp();}
-  inline void SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
+  //  Pour verifiez la compatibilite de dimensions lors de l'affectation
+  virtual TArray<T>& Set(const TArray<T>& a);
+  inline  TMatrix<T>& operator = (const TMatrix<T>& a)
+                       { Set(a);  return(*this); }
 
-  // Gestion taille/Remplissage
-  inline void Clone(const TMatrix<T>& a)  // Clone: copie des donnees de "a"
-              {mNDBlock.Clone(a.mNDBlock); mNr = a.mNr; mNc = a.mNc;}
-  inline void Reset(T v=0) {mNDBlock.Reset(v);}
-  inline void ReSize(uint_4 r,uint_4 c)  // Reallocation de place
-       {if(r==0||c==0) throw(SzMismatchError("TMatrix::ReSize r ou c==0\n"));
-        mNDBlock.ReSize(r*c); mNr = r; mNc = c;}
-  inline void Realloc(uint_4 r,uint_4 c,bool force=false)
-       {if(r==0||c==0) throw(SzMismatchError("TMatrix::Realloc r ou c==0\n"));
-        mNDBlock.Realloc(r*c,force); mNr = r; mNc = c;}
+  // Size - Changing the Size 
+  inline uint_4 NRows() const {return Size(marowi_); }
+  inline uint_4 NCols() const {return Size(macoli_); }
+  inline uint_4 NCol()  const {return Size(macoli_); } // back-compat Peida
 
-  // Informations pointeur/data
-  inline uint_4 NRows() const {return mNr;}
-  inline uint_4 NCols() const {return mNc;}
-  inline uint_4 NCol() const {return mNc;} // back-compat Peida
-  inline T const& operator()(uint_4 r,uint_4 c) const
-                            {return *(mNDBlock.Begin()+r*mNc+c);}
-  inline T&       operator()(uint_4 r,uint_4 c)
-                            {return *(mNDBlock.Begin()+r*mNc+c);}
-  inline T const& operator[](uint_4 ip) const
-                            {return *(mNDBlock.Begin()+ip);}
-  inline T&       operator[](uint_4 ip)
-                            {return *(mNDBlock.Begin()+ip);}
-  inline       T* Data()       {return mNDBlock.Begin();}
-  inline const T* Data() const {return mNDBlock.Begin();}
-  inline       NDataBlock<T>& DataBlock()       {return mNDBlock;}
-  inline const NDataBlock<T>& DataBlock() const {return mNDBlock;}
+  void ReSize(uint_4 r,uint_4 c, short mm=SameMemoryMapping);  // Reallocation de place
+  void Realloc(uint_4 r,uint_4 c, short mm=SameMemoryMapping, bool force=false);
+
+  // Sub-matrix extraction $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
+  TMatrix<T> operator () (Range rline, Range rcol) const ;
+
+  // Inline element acces methods 
+  inline T const& operator()(uint_4 r,uint_4 c) const;
+  inline T&       operator()(uint_4 r,uint_4 c);
 
   // Operations matricielles
-  TMatrix<T> Transpose(void) const;
+  TMatrix<T>& Transpose();
+  //mm = SameMemoryMapping or CMemoryMapping or FortranMemoryMapping 
+  TMatrix<T>  Transpose(short mm); 
+  // Rearranging Matrix Elements
+  TMatrix<T>  Rearrange(short mm);
 
   // Operateur d'affectation
-  // A = x (matrice diagonale x*Identite)
-  inline TMatrix<T>& operator = (T x)
-    {if(mNr!=mNc || mNr==0) throw(SzMismatchError("TMatrix::operator= mNc!=mNr ou ==0\n"));
-     for(uint_4 r=0;r<mNr;r++) for(uint_4 c=0;c<mNc;c++) (*this)(r,c)=(r==c)?x:(T)0;
-     return *this;}
-  // A = B : partage les donnees si "a" est temporaire, clone sinon.
-  inline TMatrix<T>& operator = (const TMatrix<T>& a)
-                {if(this == &a) return *this; CloneOrShare(a); return *this;}
+  // A = x (matrice diagonale Identite)
+  virtual TMatrix<T>& SetIdentity(IdentityMatrix imx);
+  inline  TMatrix<T>& operator = (IdentityMatrix imx) { return SetIdentity(imx); }
 
-  // Impression
-  void Print(ostream& os,int lp=0,uint_4 i0=0,uint_4 ni=10,uint_4 j0=0,uint_4 nj=10) const;
-  inline void Print(int lp=0,uint_4 i0=0,uint_4 ni=10,uint_4 j0=0,uint_4 nj=10) const
-              {Print(cout,lp,i0,ni,j0,nj);}
+  // Operations diverses  avec une constante
+  inline  TMatrix<T>&  operator = (T x)             { Set(x); return(*this); }
+  inline  TMatrix<T>&  operator += (T x)            { Add(x); return(*this); }
+  inline  TMatrix<T>&  operator -= (T x)            { Sub(x); return(*this); }
+  inline  TMatrix<T>&  operator *= (T x)            { Mul(x); return(*this); }
+  inline  TMatrix<T>&  operator /= (T x)            { Div(x); return(*this); }
 
-  // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) (T) x
-  inline TMatrix<T>& operator += (T b) {mNDBlock += b; return *this;}
-  inline TMatrix<T>& operator -= (T b) {mNDBlock -= b; return *this;}
-  inline TMatrix<T>& operator *= (T b) {mNDBlock *= b; return *this;}
-  inline TMatrix<T>& operator /= (T b) {mNDBlock /= b; return *this;}
+  //  operations avec matrices 
+  inline  TMatrix<T>&  operator += (const TMatrix<T>& a)  { return AddElt(a); }
+  inline  TMatrix<T>&  operator -= (const TMatrix<T>& a)  { return SubElt(a); }
 
-  // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) B
-  inline TMatrix<T>& operator += (const TMatrix<T>& a)
-              {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
-                  throw(SzMismatchError("TMatrix::operator+=A size mismatch"));
-               mNDBlock += a.mNDBlock; return *this;}
-  inline TMatrix<T>& operator -= (const TMatrix<T>& a)
-              {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
-                  throw(SzMismatchError("TMatrix::operator-=A size mismatch"));
-               mNDBlock -= a.mNDBlock; return *this;}
-  TMatrix<T>& operator *= (const TMatrix<T>& a);
+  // Input-Output
+  virtual void  Print(ostream& os, int_4 maxprt=-1, bool si=false) const ;
 
-  // Pour surcharge d'operateurs C = A (+,-,*) B
-  TMatrix<T> Add(const TMatrix<T>& b) const;
-  TMatrix<T> Sub(const TMatrix<T>& b) const;
-  TMatrix<T> Mul(const TMatrix<T>& b) const;
+  // Produit matriciel 
+  TMatrix<T>  Multiply(const TMatrix<T>& b, short mm=SameMemoryMapping) const;
+  //  inline TMatrix<T>& operator *= (const TMatrix<T>& b) 
+
+protected:
+};
+
+//  ---- inline acces methods ------
+template <class T>
+inline T const& TMatrix<T>::operator()(uint_4 r, uint_4 c) const
+{
+#ifdef SO_BOUNDCHECKING
+  if (marowi_ == 0)   CheckBound(r, c, 0, 0, 0, 4);
+  else   CheckBound(c, r, 0, 0, 0, 4);
+#endif
+  return ( *( mNDBlock.Begin()+ offset_+ 
+	      r*step_[marowi_] + c*step_[macoli_] ) );
+}
+
+template <class T>
+inline T & TMatrix<T>::operator()(uint_4 r, uint_4 c) 
+{
+#ifdef SO_BOUNDCHECKING
+  if (marowi_ == 0)   CheckBound(r, c, 0, 0, 0, 4);
+  else   CheckBound(c, r, 0, 0, 0, 4);
+#endif
+  return ( *( mNDBlock.Begin()+ offset_+ 
+	      r*step_[marowi_] + c*step_[macoli_] ) );
+}
 
 
-protected:
-  // partage les donnees si "a" temporaire, clone sinon.
-  inline void CloneOrShare(const TMatrix<T>& a)
-              {mNDBlock.CloneOrShare(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
-  // Share: partage les donnees de "a"
-  inline void Share(const TMatrix<T>& a)
-              {mNDBlock.Share(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
+// Surcharge d'operateurs C = A * B
 
-  uint_4 mNr,mNc;
-  NDataBlock<T> mNDBlock;
-};
+template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, const TMatrix<T>& b)
+{ TMatrix<T> result(a); result.SetTemp(true); result.Multiply(b);  return result;}
 
-////////////////////////////////////////////////////////////////
-// Impression
-
-template <class T>
-inline ostream& operator << (ostream& os, const TMatrix<T>& a)
-                            {a.Print(os); return(os);}
-
-////////////////////////////////////////////////////////////////
-// Surcharge d'operateurs A (+,-,*,/) (T) x
-
-template <class T> inline TMatrix<T> operator + (const TMatrix<T>& a, T b)
-    {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
-
-template <class T> inline TMatrix<T> operator + (T b,const TMatrix<T>& a)
-    {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
-
-template <class T> inline TMatrix<T> operator - (const TMatrix<T>& a, T b)
-    {TMatrix<T> result(a); result.SetTemp(true); result -= b; return result;}
-
-template <class T> inline TMatrix<T> operator - (T b,const TMatrix<T>& a)
-    {TMatrix<T> result(a); result.SetTemp(true);
-     result.DataBlock() = b-result.DataBlock(); return result;}
-
-template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, T b)
-    {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
-
-template <class T> inline TMatrix<T> operator * (T b,const TMatrix<T>& a)
-    {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
-
-template <class T> inline TMatrix<T> operator / (const TMatrix<T>& a, T b)
-    {TMatrix<T> result(a); result.SetTemp(true); result /= b; return result;}
-
-////////////////////////////////////////////////////////////////
-// Surcharge d'operateurs C = A (+,-,*,/) B
-
-template <class T>
-inline TMatrix<T> operator + (const TMatrix<T>& a,const TMatrix<T>& b)
-                  {return a.Add(b);}
-
-template <class T>
-inline TMatrix<T> operator - (const TMatrix<T>& a,const TMatrix<T>& b)
-                  {return a.Sub(b);}
-
-template <class T>
-inline TMatrix<T> operator * (const TMatrix<T>& a,const TMatrix<T>& b)
-                  {return a.Mul(b);}
-
-////////////////////////////////////////////////////////////////
-// Typedef pour simplifier et compatibilite Peida
 typedef TMatrix<r_8> Matrix;
-
-/////////////////////////////////////////////////////////////////////////
-// Classe pour la gestion de persistance
-template <class T>
-class FIO_TMatrix : public  PPersist  {
-public:
-  FIO_TMatrix();
-  FIO_TMatrix(string const & filename); 
-  FIO_TMatrix(const TMatrix<T> & obj);
-  FIO_TMatrix(TMatrix<T> * obj);
-  virtual ~FIO_TMatrix();
-  virtual AnyDataObj* DataObj();
-  virtual void        SetDataObj(AnyDataObj & o);
-  inline operator TMatrix<T>() { return(*dobj); }
-protected :
-  virtual void ReadSelf(PInPersist&);           
-  virtual void WriteSelf(POutPersist&) const;  
-  TMatrix<T> * dobj;
-  bool ownobj;
-};
-
-template <class T>
-inline POutPersist& operator << (POutPersist& os, TMatrix<T> & obj)
-{ FIO_TMatrix<T> fio(&obj);  fio.Write(os);  return(os); }
-template <class T>
-inline PInPersist& operator >> (PInPersist& is, TMatrix<T> & obj)
-{ FIO_TMatrix<T> fio(&obj);  fio.Read(is);  return(is); }
-
 
 } // Fin du namespace
