Index: trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 257)
+++ trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 259)
@@ -101,5 +101,5 @@
 if(!data) NallocData++; NallocSRef++;
 cout<<"DEBUG_NDataBlock::Alloc("<<n<<") mSRef="<<mSRef
-    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data "<< mSRef->data
+    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
     <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
@@ -132,5 +132,5 @@
 #ifdef DEBUG_NDATABLOCK
 cout<<"DEBUG_...NDataBlock::Share("<<&a<<") mSRef="<<mSRef
-    <<" mSRef->nref"<<mSRef->nref<<" mSRef->data "<< mSRef->data<<endl;
+    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data<<endl;
 #endif
 }
@@ -140,9 +140,9 @@
 // Pour detruire les pointeurs en tenant compte des references
 {
-    #ifdef DEBUG_NDATABLOCK
-    cout<<"DEBUG_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--;
@@ -167,4 +167,14 @@
 
 template <class T>
+void NDataBlock<T>::Reset(T v)
+{
+if(mSRef==NULL) return;
+if(mSRef->data==NULL) return;
+if(mSz==0) return;
+T *p=Begin(), *pe=End();
+while(p<pe) *p++ = v;
+}
+
+template <class T>
 void NDataBlock<T>::ReSize(size_t n)
 // Re-dimension, dans ce cas re-allocation de la place
@@ -195,5 +205,5 @@
 T* p = NULL;
 if(mSRef) {nr = mSRef->nref; p = mSRef->data;}
-cout<<"NDataBlock::Print nel=%ld nref=%d (%p)\n",mSz,nr,p;
+cout<<"NDataBlock::Print nel="<<mSz<<" nref="<<nr<<" ("<<p<<")"<<endl;
 if(i1>=mSz || n<=0 || !p) return;
 size_t i2 = i1+n; if(i2>mSz) i2=mSz;
@@ -314,23 +324,23 @@
 
 template <class T>
-NDataBlock<T>& Add(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);
-}
-
-template <class T>
-NDataBlock<T>& Sub(T b)
+return result += b;
+}
+
+template <class T>
+NDataBlock<T> Sub(T b)
 // Pour A-b
 {
 NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
-return (result -= b);
-}
-
-template <class T>
-NDataBlock<T>& SubInv(T b)
+return result -= b;
+}
+
+template <class T>
+NDataBlock<T> SubInv(T b)
 // Pour b-A
 {
@@ -343,23 +353,23 @@
 
 template <class T>
-NDataBlock<T>& Mult(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);
-}
-
-template <class T>
-NDataBlock<T>& Div(T b)
+return result *= b;
+}
+
+template <class T>
+NDataBlock<T> Div(T b)
 // Pour A/b
 {
 NDataBlock<T>& a = *this;
 NDataBlock<T> result(a,false); result.SetTemp(true);
-return (result /= b);
-}
-
-template <class T>
-NDataBlock<T>& DivInv(T b)
+return result /= b;
+}
+
+template <class T>
+NDataBlock<T> DivInv(T b)
 // Pour b/A
 {
@@ -374,5 +384,5 @@
 
 template <class T>
-NDataBlock<T>& Add(const NDataBlock<T>& b)
+NDataBlock<T> Add(NDataBlock<T>& b)
 // Pour A+B
 {
@@ -389,5 +399,5 @@
 
 template <class T>
-NDataBlock<T>& Mul(const NDataBlock<T>& b)
+NDataBlock<T> Mul(NDataBlock<T>& b)
 // Pour A*B
 {
@@ -404,5 +414,5 @@
 
 template <class T>
-NDataBlock<T>& Sub(const NDataBlock<T>& b)
+NDataBlock<T> Sub(NDataBlock<T>& b)
 // Pour A-B
 {
@@ -421,5 +431,5 @@
 
 template <class T>
-NDataBlock<T>& Div(const NDataBlock<T>& b)
+NDataBlock<T> Div(NDataBlock<T>& b)
 // Pour A/B
 {
Index: trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- trunk/SophyaLib/BaseTools/ndatablock.h	(revision 257)
+++ trunk/SophyaLib/BaseTools/ndatablock.h	(revision 259)
@@ -32,4 +32,5 @@
   // Gestion taille/Remplissage
   void Clone(NDataBlock<T>& a);
+  void Reset(T v=0);
   void ReSize(size_t n);
   void FillFrom(size_t n,T* data);
@@ -63,17 +64,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(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);
+  NDataBlock<T> Add(NDataBlock<T>& b);
+  NDataBlock<T> Sub(NDataBlock<T>& b);
+  NDataBlock<T> SubInv(NDataBlock<T>& b);
+  NDataBlock<T> Mul(NDataBlock<T>& b);
+  NDataBlock<T> Div(NDataBlock<T>& b);
+  NDataBlock<T> DivInv(NDataBlock<T>& b);
 
 protected:
@@ -91,29 +92,41 @@
 
 
-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>
+inline NDataBlock<T> operator + (NDataBlock<T>& a,T b)
+                      {return a.Add(b);}
+template<class T>
+inline NDataBlock<T> operator + (T b,NDataBlock<T>& a)
+                      {return a.Add(b);}
+template<class T>
+inline NDataBlock<T> operator - (NDataBlock<T>& a,T b)
+                      {return a.Sub(b);}
+template<class T>
+inline NDataBlock<T> operator - (T b,NDataBlock<T>& a)
+                      {return a.SubInv(b);}
+template<class T>
+inline NDataBlock<T> operator * (NDataBlock<T>& a,T b)
+                      {return a.Mul(b);}
+template<class T>
+inline NDataBlock<T> operator * (T b,NDataBlock<T>& a)
+                      {return a.Mul(b);}
+template<class T>
+inline NDataBlock<T> operator / (NDataBlock<T>& a,T b)
+                      {return a.Div(b);}
+template<class T>
+inline NDataBlock<T> operator / (T b,NDataBlock<T>& a)
+                      {return a.DivInv(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);}
+template<class T>
+inline NDataBlock<T> operator + (NDataBlock<T>& a,NDataBlock<T>& b)
+                     {return a.Add(b);}
+template<class T>
+inline NDataBlock<T> operator - (NDataBlock<T>& a,NDataBlock<T>& b)
+                      {return a.Sub(b);}
+template<class T>
+inline NDataBlock<T> operator * (NDataBlock<T>& a,NDataBlock<T>& b)
+                      {return a.Mul(b);}
+template<class T>
+inline NDataBlock<T> operator / (NDataBlock<T>& a,NDataBlock<T>& b)
+                      {return a.Div(b);}
 
 
