Index: trunk/SophyaLib/NTools/tmatrix.cc
===================================================================
--- trunk/SophyaLib/NTools/tmatrix.cc	(revision 286)
+++ trunk/SophyaLib/NTools/tmatrix.cc	(revision 288)
@@ -1,3 +1,3 @@
-// $Id: tmatrix.cc,v 1.2 1999-04-30 11:02:52 ansari Exp $
+// $Id: tmatrix.cc,v 1.3 1999-05-03 16:55:22 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -13,5 +13,5 @@
 
 ////////////////////////////////////////////////////////////////
-//************ Createur, Destructeur, gestion des donnees
+//**** Createur, Destructeur
 
 template <class T>
@@ -39,5 +39,5 @@
 template <class T>
 TMatrix<T>::TMatrix(const TMatrix<T>& a)
-// Constructeur par copie (partage des donnees).
+// Constructeur par copie (partage si "a" temporaire).
 : mNr(a.mNr), mNc(a.mNc), mNDBlock(a.mNDBlock)
 {
@@ -46,5 +46,5 @@
 template <class T>
 TMatrix<T>::TMatrix(const TMatrix<T>& a,bool share)
-// Constructeur par copie.
+// Constructeur par copie avec possibilite de forcer le partage ou non.
 : mNr(a.mNr), mNc(a.mNc), mNDBlock(a.mNDBlock,share)
 {
@@ -58,51 +58,16 @@
 
 ////////////////////////////////////////////////////////////////
-template <class T>
-void TMatrix<T>::Clone(const TMatrix<T>& a)
-// Clone (copie de donnees) a partir de "a"
-// Partage des donnees si "a" est temporaire.
-{
-mNDBlock.Clone(a.mNDBlock); mNr = a.mNr; mNc = a.mNc;
-}
-
-template <class T>
-void TMatrix<T>::Reset(T v)
-// Reset de la matrice a "v"
-{
-mNDBlock.Reset(v);
-}
-
-template <class T>
-void TMatrix<T>::Realloc(uint_4 r,uint_4 c,bool force_alloc)
-// Reallocation de place
-{
-if(r==0 || c==0) throw(SzMismatchError("TMatrix::ReSize r ou c==0\n"));
-if(!force_alloc && mNr==r && mNc==c)  return;
-mNr = r; mNc = c; mNDBlock.ReSize(r*c,force_alloc);
-}
-
-////////////////////////////////////////////////////////////////
-//**** Surcharge de TMatrix=TMatrix; TMatrix=<T> b; 
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator = (T x)
-// Operateur d'affectation depuis scalaire : identite * scalaire.
-{
-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: 0;
-return *this;
-}
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator = (const TMatrix<T>& a)
-// Operateur d'affectation A=a
-// (Re)allocation de la place memoire
-// sauf si "a" est cree temporairement (partage)
-{
-if(this == &a) return *this;
-Clone(a);
-return *this;
+// Operations matricielles
+template <class T>
+TMatrix<T> TMatrix<T>::Transpose(void) const
+// Transposition
+{
+TMatrix<T> a; a.Clone(*this); a.SetTemp(true);
+a.mNr = mNc; a.mNc = mNr;
+{for(int i=0; i<mNr; i++)
+  for(int j=0; j<mNc; j++) {
+    a(j,i) = (*this)(i,j);
+}}
+return a;
 }
 
@@ -115,5 +80,5 @@
 // Impression de la sous-matrice (i:i+ni-1,i:j+nj-1)
 {
-  os<<"TMatrix::Print("<<mNr<<","<<mNc<<")"<<endl;
+os<<"TMatrix::Print("<<mNr<<","<<mNc<<")"<<endl;
 if(lp>0)
   {os<<"       this="<<this<<endl; mNDBlock.Print(0,0);}
@@ -129,54 +94,5 @@
 
 ////////////////////////////////////////////////////////////////
-//**** Surcharge de +=,-=,*=,/= (INPLACE): TMatrix += <T> b;
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator += (T b)
-{
-mNDBlock += b;
-return *this;
-}
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator -= (T b)
-{
-mNDBlock -= b;
-return *this;
-}
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator *= (T b)
-{
-mNDBlock *= b;
-return *this;
-}
-
-template <class T>
-TMatrix<T>& TMatrix<T>::operator /= (T b)
-{
-mNDBlock /= b;
-return *this;
-}
-
-////////////////////////////////////////////////////////////////
-//**** Surcharge de +=,-=,*= (INPLACE): TMatrix += TMatrix;
-
-template <class T>
-TMatrix<T>& 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;
-}
-
-template <class T>
-TMatrix<T>& 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;
-}
+//**** Surcharge de *= (INPLACE): TMatrix *= TMatrix;
 
 template <class T>
@@ -209,47 +125,30 @@
 
 ////////////////////////////////////////////////////////////////
-//**** Surcharge de +,-,*: TMatrix = TMatrix + TMatrix;
-
-template <class T>
-TMatrix<T> TMatrix<T>::Add(const TMatrix<T>& b) const
-// C = A(this)+B
+//**** Pour surcharge d'operateurs C = A (+,-,*,/) B
+
+template <class T> TMatrix<T> TMatrix<T>::Add(const TMatrix<T>& b) const
 {
 if(mNr!=b.mNr || mNc!=b.mNc)
-  throw(SzMismatchError("NDataBlock operator C=A+B size mismatch\n"));
-TMatrix<T> result; result.SetTemp(true);
-if(b.IsTemp()) {
-  result.Clone(b);
-  result += *this;
-} else {
-  result.Clone(*this);
-  result += b;
-}
+    throw(SzMismatchError("NDataBlock operator C=A+B size mismatch\n"));
+TMatrix<T> result; result.SetTemp(true); result.mNr=mNr; result.mNc=mNc;
+result.mNDBlock = mNDBlock+b.mNDBlock;
 return result;
 }
 
-template <class T>
-TMatrix<T> TMatrix<T>::Sub(const TMatrix<T>& b) const
-// C = A(this)-B
+template <class T> TMatrix<T> TMatrix<T>::Sub(const TMatrix<T>& b) const
 {
 if(mNr!=b.mNr || mNc!=b.mNc)
-  throw(SzMismatchError("NDataBlock operator C=A-B size mismatch\n"));
-TMatrix<T> result; result.SetTemp(true);
-if(b.IsTemp()) {
-  result.Clone(b);
-  result.mNDBlock = (*this).mNDBlock - result.mNDBlock;
-} else {
-  result.Clone(*this);
-  result -= b;
-}
+    throw(SzMismatchError("NDataBlock operator C=A-B size mismatch\n"));
+TMatrix<T> result; result.SetTemp(true); result.mNr=mNr; result.mNc=mNc;
+result.mNDBlock = mNDBlock-b.mNDBlock;
 return result;
 }
 
-template <class T>
-TMatrix<T> TMatrix<T>::Mul(const TMatrix<T>& b) const
+template <class T> TMatrix<T> TMatrix<T>::Mul(const TMatrix<T>& b) const
 // C = A(this)*B : Cij = Aik Bkj (allocation forcee dans tous les cas)
 {
 if(mNr==0 || mNc==0 || b.mNc==0 || mNc!=b.mNr)
   throw(SzMismatchError("NDataBlock operator C=A*B size mismatch\n"));
-TMatrix<T> r; r.SetTemp(true); r.Realloc(mNr,b.mNc,true);
+TMatrix<T> r; r.SetTemp(true); r.ReSize(mNr,b.mNc);
 T *ai,*aik,*bj,*bkj,*ri,*rij;
 for(ri=const_cast<T *>(r.Data()),ai=const_cast<T *>(Data());
@@ -317,5 +216,5 @@
 is.Get(itab,2);
 if (dobj == NULL) dobj = new TMatrix<T>(itab[0],itab[1]);
-else dobj->Realloc(itab[0],itab[1],false);
+else dobj->ReSize(itab[0],itab[1]);
 // On lit le NDataBlock
 //cmv   encore des problemes avec les consteries
@@ -331,5 +230,5 @@
 uint_4 itab[2];
 itab[0] = dobj->NRows();
-itab[1] = dobj->NCol();
+itab[1] = dobj->NCols();
 os.Put(itab,2);
 // On ecrit le NDataBlock
