Index: /trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 256)
+++ /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 257)
@@ -76,7 +76,18 @@
 // Si br==NULL   : les donnees nous appartiennent
 //    br!=NULL   : les donnees ne nous appartiennent pas (ex Blitz)
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"NDataBlock::Alloc("<<n<<") mSRef="<<mSRef<<endl;
+// Exemple: on veut connecter a un tableau de T*
+// -- On veut que NDataBlock ne desalloue pas le tableau
+//   float *x = new float[5]; ... remplissage de x[] ...;
+//   NDataBlock A(5,x,new Bridge);
+//   delete [] x;   // Il faut deleter explicitement
+// -- On veut que NDataBlock desalloue le tableau
+//          ( Ne Pas Faire "delete [] x;" )
+//   float *x = new float[5]; ... remplissage de x[] ...;
+//   NDataBlock A(5,x);
+//   -- Autre solution:
+//   NDataBlock A(5); A.FillFrom(5,x);
+{
+#ifdef DEBUG_NDATABLOCK
+cout<<"DEBUG_NDataBlock::Alloc("<<n<<") mSRef="<<mSRef<<endl;
 #endif
 if(n==0) throw(SzMismatchError("NDataBlock::Alloc n==0\n"));
@@ -89,6 +100,6 @@
 #ifdef DEBUG_NDATABLOCK
 if(!data) NallocData++; NallocSRef++;
-cout<<"NDataBlock::Alloc("<<n<<") mSRef="<<mSRef
-    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data"<< mSRef->data
+cout<<"DEBUG_NDataBlock::Alloc("<<n<<") mSRef="<<mSRef
+    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data "<< mSRef->data
     <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
@@ -100,5 +111,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"NDataBlock::Clone("<<&a<<endl;
+  cout<<"DEBUG_NDataBlock::Clone("<<&a<<")"<<endl;
 #endif
 if(!a.mSRef) {mSz=0; mSRef=NULL;} // cas ou "a" est cree par defaut
@@ -112,5 +123,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"NDataBlock::Share("<<&a<<") a.mSRef="<<a.mSRef<<" mSRef="<<mSRef<<endl;
+cout<<"DEBUG_NDataBlock::Share("<<&a<<") a.mSRef="<<a.mSRef<<" mSRef="<<mSRef<<endl;
 #endif
 if(&a==NULL) throw(NullPtrError("NDataBlock::Share  &a==NULL\n"));
@@ -120,6 +131,6 @@
 mSz = a.mSz; mSRef = a.mSRef; mSRef->nref++;
 #ifdef DEBUG_NDATABLOCK
-cout<<"...NDataBlock::Share("<<&a<<") mSRef="<<mSRef
-    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data"<< mSRef->data<<endl;
+cout<<"DEBUG_...NDataBlock::Share("<<&a<<") mSRef="<<mSRef
+    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data "<< mSRef->data<<endl;
 #endif
 }
@@ -129,14 +140,14 @@
 // Pour detruire les pointeurs en tenant compte des references
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"NDataBlock::Delete() mSRef="<<mSRef;
-if(mSRef) cout<<" mSRef->nref"<<mSRef->nref<<" mSRef->data"<<mSRef->data;
-cout<<endl;
-#endif
+    #ifdef DEBUG_NDATABLOCK
+    cout<<"DEBUG_NDataBlock::Delete() mSRef="<<mSRef;
+    if(mSRef) cout<<" mSRef->nref"<<mSRef->nref<<" mSRef->data "<<mSRef->data;
+    cout<<endl;
+    #endif
 if(mSRef==NULL) return; // cas du createur par defaut
 mSRef->nref--;
 if(mSRef->nref != 0) {
 #ifdef DEBUG_NDATABLOCK
-  cout<<"...NDataBlock::Delete() pas de desallocation il reste nref="<<mSRef->nref<<endl;
+  cout<<"DEBUG_...NDataBlock::Delete() pas de desallocation il reste nref="<<mSRef->nref<<endl;
 #endif
   return;
@@ -144,5 +155,5 @@
 #ifdef DEBUG_NDATABLOCK
 if(!mSRef->bridge) NallocData--; NallocSRef--;
-cout<<"...NNDataBlock::Delete() desallocation complete il reste nref="<<mSRef->nref
+cout<<"DEBUG_...NNDataBlock::Delete() desallocation complete il reste nref="<<mSRef->nref
     <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
@@ -162,4 +173,17 @@
 }
 
+template <class T>
+void NDataBlock<T>::FillFrom(size_t n,T* data)
+// Remplissage par un tableau de donnees
+// - Si classe vide : creation de l'espace memoire
+// - Si classe connectee : on ecrit selon la longueur
+{
+if(data==NULL) throw(NullPtrError("NDataBlock::FillFrom  data==NULL\n"));
+if(n==0) throw(ParmError("NDataBlock::FillFrom  n<=0\n"));
+if(mSRef==NULL) Alloc(n); // cas du createur par default
+if(mSz<n) n= mSz;
+memcpy(Data(),data,n*sizeof(T));
+}
+
 //**** Impression
 
@@ -174,9 +198,11 @@
 if(i1>=mSz || n<=0 || !p) return;
 size_t i2 = i1+n; if(i2>mSz) i2=mSz;
-size_t im = 1;
+size_t im = 1; bool enl;
 while(i1<i2) {
+  enl = false;
   cout<<" "<<(*this)(i1);  i1++;
-  if(im==10) {cout<<"\n"; im=1;} else im++;
-}
+  if(im==10) {cout<<"\n"; im=1; enl=true;} else im++;
+}
+if(!enl) cout<<endl;
 }
 
@@ -284,12 +310,12 @@
 }
 
-//**** FIN DES METHODES DE LA CLASSE
-
 //**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b; NDataBlock = <T>b+NDataBlock;
 // ATTENTION: re-affectation imposee
 
 template <class T>
-NDataBlock<T> operator + (const NDataBlock<T>& a, T b)
-{
+NDataBlock<T>& Add(T b)
+// Pour A+b
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 return (result += b);
@@ -297,13 +323,8 @@
 
 template <class T>
-NDataBlock<T> operator + (T b, const NDataBlock<T>& a)
-{
-NDataBlock<T> result(a,false); result.SetTemp(true);
-return (result += b);
-}
-
-template <class T>
-NDataBlock<T> operator - (const NDataBlock<T>& a, T b)
-{
+NDataBlock<T>& Sub(T b)
+// Pour A-b
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 return (result -= b);
@@ -311,6 +332,8 @@
 
 template <class T>
-NDataBlock<T> operator - (T b, const NDataBlock<T>& a)
-{
+NDataBlock<T>& SubInv(T b)
+// Pour b-A
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
@@ -320,6 +343,8 @@
 
 template <class T>
-NDataBlock<T> operator * (const NDataBlock<T>& a, T b)
-{
+NDataBlock<T>& Mult(T b)
+// Pour A*b
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 return (result *= b);
@@ -327,13 +352,8 @@
 
 template <class T>
-NDataBlock<T> operator * (T b, const NDataBlock<T>& a)
-{
-NDataBlock<T> result(a,false); result.SetTemp(true);
-return (result *= b);
-}
-
-template <class T>
-NDataBlock<T> operator / (const NDataBlock<T>& a, T b)
-{
+NDataBlock<T>& Div(T b)
+// Pour A/b
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 return (result /= b);
@@ -341,6 +361,8 @@
 
 template <class T>
-NDataBlock<T> operator / (T b, const NDataBlock<T>& a)
-{
+NDataBlock<T>& DivInv(T b)
+// Pour b/A
+{
+NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
 T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
@@ -352,6 +374,8 @@
 
 template <class T>
-NDataBlock<T> operator + (const NDataBlock<T>& a, const NDataBlock<T>& b)
-{
+NDataBlock<T>& Add(const NDataBlock<T>& b)
+// Pour A+B
+{
+NDataBlock<T>& a = *this;
 if(a.mSz!=b.mSz) throw(SzMismatchError("NDataBlock operator C=A+B size mismatch/null\n"));
 if(b.IsTemp()) {
@@ -365,6 +389,8 @@
 
 template <class T>
-NDataBlock<T> operator * (const NDataBlock<T>& a, const NDataBlock<T>& b)
-{
+NDataBlock<T>& Mul(const NDataBlock<T>& b)
+// Pour A*B
+{
+NDataBlock<T>& a = *this;
 if(a.mSz!=b.mSz) throw(SzMismatchError("NDataBlock operator C=A*B size mismatch/null\n"));
 if(b.IsTemp()) {
@@ -378,6 +404,8 @@
 
 template <class T>
-NDataBlock<T> operator - (const NDataBlock<T>& a, const NDataBlock<T>& b)
-{
+NDataBlock<T>& Sub(const NDataBlock<T>& b)
+// Pour A-B
+{
+NDataBlock<T>& a = *this;
 if(a.mSz!=b.mSz) throw(SzMismatchError("NDataBlock operator C=A-B size mismatch/null\n"));
 if(b.IsTemp()) {
@@ -393,6 +421,8 @@
 
 template <class T>
-NDataBlock<T> operator / (const NDataBlock<T>& a, const NDataBlock<T>& b)
-{
+NDataBlock<T>& Div(const NDataBlock<T>& b)
+// Pour A/B
+{
+NDataBlock<T>& a = *this;
 if(a.mSz!=b.mSz) throw(SzMismatchError("NDataBlock operator C=A/B size mismatch/null\n"));
 if(b.IsTemp()) {
@@ -406,6 +436,4 @@
 }
 }
-
-
 
 
@@ -421,6 +449,7 @@
 #pragma define_template NDataBlock<r_4>
 #pragma define_template NDataBlock<r_8>
-#pragma define_template NDataBlock< complex<float> >
-#pragma define_template NDataBlock< complex<double> >
+// pas de definitions de cout pour les complex ??
+//#pragma define_template NDataBlock< complex<float> >
+//#pragma define_template NDataBlock< complex<double> >
 #endif
 
@@ -454,13 +483,2 @@
 template class NDataBlock< complex<double> >;
 #endif
-
-#ifdef __CXX_PRAGMA_TEMPLATES__
-#pragma define_template (operator+) <float,float> mais comment on fait ca! CMV_A_FAIRE
-#endif
-
-#ifdef __GNU_TEMPLATES__
-template NDataBlock<T> operator + (const NDataBlock<T>&, const NDataBlock<T>&); mais comment on fait ca! CMV_A_FAIRE
-#endif
-
-#if defined(__ANSI_TEMPLATES__) 
-#endif
Index: /trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 256)
+++ /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 257)
@@ -30,7 +30,8 @@
   inline void SetTemp(bool temp) {mIsTemp=temp;}
 
-  // Gestion taille
+  // Gestion taille/Remplissage
   void Clone(NDataBlock<T>& a);
   void ReSize(size_t n);
+  void FillFrom(size_t n,T* data);
   
   // Informations pointeur/data
@@ -62,4 +63,17 @@
   NDataBlock<T>& operator /= (NDataBlock<T>& a);
 
+  NDataBlock<T>& Add(T b);
+  NDataBlock<T>& Sub(T b);
+  NDataBlock<T>& SubInv(T b);
+  NDataBlock<T>& Mul(T b);
+  NDataBlock<T>& Div(T b);
+  NDataBlock<T>& DivInv(T b);
+
+  NDataBlock<T>& Add(const NDataBlock<T>& b);
+  NDataBlock<T>& Sub(const NDataBlock<T>& b);
+  NDataBlock<T>& SubInv(const NDataBlock<T>& b);
+  NDataBlock<T>& Mul(const NDataBlock<T>& b);
+  NDataBlock<T>& Div(const NDataBlock<T>& b);
+  NDataBlock<T>& DivInv(const NDataBlock<T>& b);
 
 protected:
@@ -77,16 +91,30 @@
 
 
-template<class T> NDataBlock<T> operator + (const NDataBlock<T>& a, T b);
-template<class T> NDataBlock<T> operator + (T b,const NDataBlock<T>& a);
-template<class T> NDataBlock<T> operator - (const NDataBlock<T>& a, T b);
-template<class T> NDataBlock<T> operator - (T b,const NDataBlock<T>& a);
-template<class T> NDataBlock<T> operator * (const NDataBlock<T>& a, T b);
-template<class T> NDataBlock<T> operator * (T b, const NDataBlock<T>& a);
-template<class T> NDataBlock<T> operator / (const NDataBlock<T>& a, T b);
+template<class T> inline NDataBlock<T> operator + (const NDataBlock<T>& a,T b)
+                                                  {return a.Add(b);}
+template<class T> inline NDataBlock<T> operator + (T b,const NDataBlock<T>& a)
+                                                  {return a.Add(b);}
+template<class T> inline NDataBlock<T> operator - (const NDataBlock<T>& a,T b)
+                                                  {return a.Sub(b);}
+template<class T> inline NDataBlock<T> operator - (T b,const NDataBlock<T>& a)
+                                                  {return a.SubInv(b);}
+template<class T> inline NDataBlock<T> operator * (const NDataBlock<T>& a,T b)
+                                                  {return a.Mul(b);}
+template<class T> inline NDataBlock<T> operator * (T b,const NDataBlock<T>& a)
+                                                  {return a.Mul(b);}
+template<class T> inline NDataBlock<T> operator / (const NDataBlock<T>& a,T b)
+                                                  {return a.Div(b);}
+template<class T> inline NDataBlock<T> operator / (T b,const NDataBlock<T>& a)
+                                                  {return a.DivInv(b);}
 
-template<class T> NDataBlock<T> operator + (const NDataBlock<T>& a, const NDataBlock<T>& b);
-template<class T> NDataBlock<T> operator - (const NDataBlock<T>& a, const NDataBlock<T>& b);
-template<class T> NDataBlock<T> operator * (const NDataBlock<T>& a, const NDataBlock<T>& b);
-template<class T> NDataBlock<T> operator / (const NDataBlock<T>& a, const NDataBlock<T>& b);
+template<class T> inline NDataBlock<T> operator + (const NDataBlock<T>& a,const NDataBlock<T>& b)
+                                                  {return a.Add(b);}
+template<class T> inline NDataBlock<T> operator - (const NDataBlock<T>& a,const NDataBlock<T>& b)
+                                                  {return a.Sub(b);}
+template<class T> inline NDataBlock<T> operator * (const NDataBlock<T>& a,const NDataBlock<T>& b)
+                                                  {return a.Mul(b);}
+template<class T> inline NDataBlock<T> operator / (const NDataBlock<T>& a,const NDataBlock<T>& b)
+                                                  {return a.Div(b);}
+
 
 #endif
