Changeset 268 in Sophya


Ignore:
Timestamp:
Apr 26, 1999, 5:32:23 PM (26 years ago)
Author:
ansari
Message:

fin ndataBlock + AnyDataObj cree rz+cmv 26/4/99

Location:
trunk/SophyaLib/BaseTools
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/BaseTools/machdefs.h

    r245 r268  
    188188/***********************************************************************/
    189189
    190 /* Some features will be *required* for Planck. Which ones ?           */
     190/* Some features will be *required* for Planck. Which ones ?               */
    191191 
    192 /*   ANSI_TEMPLATES        : use ANSI syntax for explicit templates      */
    193 /*   GNUG_TEMPLATES        : use GNU syntax for explicit templates       */
    194 /*   PRAGMA_TEMPLATES      : use pragma template, a la cxx               */
    195 /*   COMPILER_EXCEPTIONS   : knows about exceptions  --- required ?      */
    196 /*   STREAMPOS_IS_CLASS    : streampos is a real class                   */
    197 /*   ITER_TAG              : use iter_tag for iterator qualifiers in STL */
    198 /*   NO_STRSTREAM          : does not have strstream                     */
    199 /*   HAS_EXPLICIT          : knows about explicit keyword - constructors */
    200 /*   HAS_IOS_BIN                                                         */
    201 /*   HAS_IOS_NOCREATE                                                    */
    202 /*   HAS_VEC_NEW           : operator new[]                              */
    203 /*   ANSI_IO               : rdbuf()->pubseekoff rather than seekg       */
    204 /*   HAS_STR_NPOS          : has string::npos and not a global NPOS      */
     192/*   ANSI_TEMPLATES        : use ANSI syntax for explicit templates        */
     193/*   GNUG_TEMPLATES        : use GNU syntax for explicit templates         */
     194/*   PRAGMA_TEMPLATES      : use pragma template, a la cxx                 */
     195/*   COMPILER_EXCEPTIONS   : knows about exceptions  --- required ?        */
     196/*   STREAMPOS_IS_CLASS    : streampos is a real class                     */
     197/*   ITER_TAG              : use iter_tag for iterator qualifiers in STL   */
     198/*   NO_STRSTREAM          : does not have strstream                       */
     199/*   HAS_EXPLICIT          : knows about explicit keyword - constructors   */
     200/*   HAS_IOS_BIN                                                           */
     201/*   HAS_IOS_NOCREATE                                                      */
     202/*   HAS_VEC_NEW           : operator new[]                                */
     203/*   ANSI_IO               : rdbuf()->pubseekoff rather than seekg         */
     204/*   HAS_STR_NPOS          : has string::npos and not a global NPOS        */
     205/*   NO_IOS_COMPLEX        : does not have operator << defined for complex */
    205206
    206207

  • trunk/SophyaLib/BaseTools/ndatablock.cc

    r267 r268  
     1// Gestion de block de donnees avec partage de references
     2//                         C.Magneville          04/99
     3// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
    14#include "machdefs.h"
    25#include <stdio.h>
    … …  
    710#include "ndatablock.h"
    811
    9 #define DEBUG_NDATABLOCK
     12using namespace PlanckDPC;
     13
     14//define DEBUG_NDATABLOCK
    1015
    1116#ifdef DEBUG_NDATABLOCK
    … …  
    2530: mSz(0), mSRef(NULL), mIsTemp(false)
    2631{
     32#ifdef DEBUG_NDATABLOCK
     33cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",n="<<n<<")"<<endl;
     34#endif
     35
    2736Alloc(n);
    2837}
    … …  
    3342: mSz(0), mSRef(NULL), mIsTemp(false)
    3443{
     44#ifdef DEBUG_NDATABLOCK
     45cout<<"DEBUG_NDataBlock::NDataBlock("<<this
     46    <<",data="<<data<<",br="<<br<<")"<<endl;
     47#endif
     48
    3549Alloc(n,data,br);
    3650}
    … …  
    4155: mSz(0), mSRef(NULL), mIsTemp(false)
    4256{
    43 }
    44 
    45 template <class T>
    46 NDataBlock<T>::NDataBlock(NDataBlock<T>& a)
     57#ifdef DEBUG_NDATABLOCK
     58cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<") default"<<endl;
     59#endif
     60}
     61
     62template <class T>
     63NDataBlock<T>::NDataBlock(const NDataBlock<T>& a)
    4764// Createur par copie
    4865// ATTENTION: partage les donnees avec "a"
    … …  
    5168: mSz(0), mSRef(NULL), mIsTemp(false)
    5269{
     70#ifdef DEBUG_NDATABLOCK
     71cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<") a.(mSz="
     72    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()<<")"<<endl;
     73#endif
     74
    5375Share(a);
    5476}
    5577
    5678template <class T>
    57 NDataBlock<T>::NDataBlock(NDataBlock<T>& a,bool share)
     79NDataBlock<T>::NDataBlock(const NDataBlock<T>& a,bool share)
    5880// Createur avec choix de partager ou non
    5981: mSz(0), mSRef(NULL), mIsTemp(false)
    6082{
     83#ifdef DEBUG_NDATABLOCK
     84cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<",sh=<<"<<share<<")"
     85    <<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()<<")"<<endl;
     86#endif
     87
    6188if(share) Share(a); else Clone(a);
    6289}
    … …  
    6693// Destructeur
    6794{
     95#ifdef DEBUG_NDATABLOCK
     96cout<<"DEBUG_NDataBlock::~NDataBlock("<<this<<")"<<endl;
     97#endif
     98
    6899Delete();
    69100}
    70101
    71102template <class T>
    72 void NDataBlock<T>::SetTemp(bool temp)
     103void NDataBlock<T>::SetTemp(bool temp) const
    73104// Set temporary
    74105{
    75106mIsTemp=temp;
    76     #ifdef DEBUG_NDATABLOCK
    77     cout<<"DEBUG_NDataBlock::SetTemp("<<this<<","<<temp
    78         <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
    79     #endif
     107
     108#ifdef DEBUG_NDATABLOCK
     109cout<<"DEBUG_NDataBlock::SetTemp("<<this<<","<<temp
     110    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
     111#endif
    80112}
    81113
    … …  
    99131//   NDataBlock A(5); A.FillFrom(5,x);
    100132{
    101     #ifdef DEBUG_NDATABLOCK
    102     cout<<"DEBUG_NDataBlock::Alloc("<<this<<","
    103         <<n<<","<<data<<","<<br<<") mSz="<<mSz
    104         <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
    105     #endif
     133#ifdef DEBUG_NDATABLOCK
     134cout<<"DEBUG_NDataBlock::Alloc("<<this<<","
     135    <<n<<","<<data<<","<<br<<") mSz="<<mSz
     136    <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
     137#endif
     138
    106139if(n==0) throw(SzMismatchError("NDataBlock::Alloc n==0\n"));
    107140if(mSRef) Delete();
    … …  
    111144if(data) mSRef->data = data; else mSRef->data = new T[n];
    112145mSRef->bridge = br;
    113     #ifdef DEBUG_NDATABLOCK
    114     if(!data) NallocData++; NallocSRef++;
    115     cout<<"...DEBUG_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
    116         <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
    117         <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp
    118         <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
    119     #endif
    120 }
    121 
    122 template <class T>
    123 void NDataBlock<T>::Clone(NDataBlock<T>& a)
     146
     147#ifdef DEBUG_NDATABLOCK
     148if(!data) NallocData++; NallocSRef++;
     149cout<<"...DEBUG_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
     150    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
     151    <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp
     152    <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
     153#endif
     154}
     155
     156template <class T>
     157void NDataBlock<T>::Clone(const NDataBlock<T>& a)
    124158// Clone (copie de donnee) a partir de "a"
    125159{
    … …  
    135169
    136170template <class T>
    137 void NDataBlock<T>::Share(NDataBlock<T>& a)
     171void NDataBlock<T>::Share(const NDataBlock<T>& a)
    138172// Partage des donnees avec "a"
    139173{
    140     #ifdef DEBUG_NDATABLOCK
    141     cout<<"DEBUG_NDataBlock::Share("<<this<<","<<&a<<")";
    142     if(&a!=NULL) cout<<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef
    143                      <<" IsTemp="<<a.IsTemp()<<")";
    144     cout<<", mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
    145     #endif
     174#ifdef DEBUG_NDATABLOCK
     175cout<<"DEBUG_NDataBlock::Share("<<this<<","<<&a<<")";
     176if(&a!=NULL) cout<<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef
     177                 <<" IsTemp="<<a.IsTemp()<<")";
     178cout<<", mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
     179#endif
     180
    146181if(&a==NULL) throw(NullPtrError("NDataBlock::Share  &a==NULL\n"));
    147182// on ne peut partager si "a" pas alloue
    … …  
    149184if(mSRef) Delete();
    150185mSz = a.mSz; mSRef = a.mSRef; mSRef->nref++;
    151     #ifdef DEBUG_NDATABLOCK
    152     cout<<"...DEBUG_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
    153         <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
    154         <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp<<endl;
    155     #endif
     186
     187#ifdef DEBUG_NDATABLOCK
     188cout<<"...DEBUG_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
     189    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
     190    <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp<<endl;
     191#endif
    156192}
    157193
    … …  
    160196// Pour detruire les pointeurs en tenant compte des references
    161197{
    162     #ifdef DEBUG_NDATABLOCK
    163     cout<<"DEBUG_NDataBlock::Delete("<<this<<") mSz="<<mSz
    164         <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp;
    165     if(mSRef)
    166       cout<<" mSRef->nref="<<mSRef->nref<<" mSRef->data="
    167           <<mSRef->data<<" mSRef->bridge="<<mSRef->bridge;
    168     cout<<endl;
    169     #endif
     198#ifdef DEBUG_NDATABLOCK
     199cout<<"DEBUG_NDataBlock::Delete("<<this<<") mSz="<<mSz
     200    <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp;
     201if(mSRef)
     202  cout<<" mSRef->nref="<<mSRef->nref<<" mSRef->data="
     203      <<mSRef->data<<" mSRef->bridge="<<mSRef->bridge;
     204cout<<endl;
     205#endif
     206
    170207if(mSRef==NULL) return; // cas du createur par defaut
    171208mSRef->nref--;
    172209if(mSRef->nref != 0) {
    173     #ifdef DEBUG_NDATABLOCK
    174       cout<<"...DEBUG_NDataBlock::Delete() pas de desallocation il reste nref="
    175           <<mSRef->nref<<endl;
    176     #endif
     210
     211#ifdef DEBUG_NDATABLOCK
     212cout<<"...DEBUG_NDataBlock::Delete() pas de desallocation il reste nref="
     213    <<mSRef->nref<<endl;
     214#endif
     215
    177216  return;
    178217}
    179     #ifdef DEBUG_NDATABLOCK
    180     if(!mSRef->bridge) NallocData--; NallocSRef--;
    181     cout<<"...DEBUG_NDataBlock::Delete() desallocation complete il reste nref="
    182         <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
    183     #endif
     218
     219#ifdef DEBUG_NDATABLOCK
     220if(!mSRef->bridge) NallocData--; NallocSRef--;
     221cout<<"...DEBUG_NDataBlock::Delete() desallocation complete il reste nref="
     222    <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
     223#endif
     224
    184225// Si il y a un Bridge les donnees ne n'appartiennent pas, on detruit le Bridge
    185226if(mSRef->bridge) delete mSRef->bridge;
    … …  
    223264
    224265template <class T>
    225 void NDataBlock<T>::Print(size_t i1,size_t n)
     266void NDataBlock<T>::Print(ostream& os,size_t i1,size_t n) const
    226267// Impression de n elements a partir de i1
    227268{
    … …  
    229270T* p = NULL; Bridge* br = NULL;
    230271if(mSRef) {nr = mSRef->nref; p = mSRef->data; br = mSRef->bridge;}
    231 cout<<"NDataBlock::Print("<<this<<",Sz="<<mSz<<",IsTemp="<<mIsTemp<<")\n"
    232     <<"            mSRef="<<mSRef<<"(nref="<<nr<<",data="<<p
    233     <<",bridge="<<br<<")"<<endl;
     272os<<"NDataBlock::Print("<<this<<",Sz="<<mSz<<",IsTemp="<<mIsTemp<<")\n"
     273  <<"            mSRef="<<mSRef<<"(nref="<<nr<<",data="<<p
     274  <<",bridge="<<br<<")"<<endl;
    234275if(i1>=mSz || n<=0 || !p) return;
    235276size_t i2 = i1+n; if(i2>mSz) i2=mSz;
    … …  
    237278while(i1<i2) {
    238279  enl = false;
    239   cout<<" "<<(*this)(i1);  i1++;
    240   if(im==10) {cout<<"\n"; im=1; enl=true;} else im++;
    241 }
    242 if(!enl) cout<<endl;
     280  os<<" "<<(*this)(i1);  i1++;
     281  if(im==8) {os<<"\n"; im=1; enl=true;} else im++;
     282}
     283if(!enl) os<<endl;
    243284}
    244285
    … …  
    246287
    247288template <class T>
    248 NDataBlock<T>& NDataBlock<T>::operator = (NDataBlock<T>& a)
     289NDataBlock<T>& NDataBlock<T>::operator = (const NDataBlock<T>& a)
    249290// surcharge avec partage des donnees
    250291// Ecriture:  NDataBlock a; a = b;
    251292//            NDataBlock a(10); a = b; (a est re-affecte)
    252293{
     294#ifdef DEBUG_NDATABLOCK
     295cout<<"DEBUG_NDataBlock::operator=("<<this<<","<<&a<<") a.(mSz="
     296    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
     297    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
     298#endif
     299
    253300if(this == &a) return *this;
    254301if(a.mSz!=mSz)
    … …  
    264311// NDataBlock a; a = v; ou bien NDataBlock a(10); a = v;
    265312{
     313#ifdef DEBUG_NDATABLOCK
     314cout<<"DEBUG_NDataBlock::operator=("<<this<<","<<v<<")"
     315    <<" mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
     316#endif
     317
    266318if(mSz==0) throw(SzMismatchError("NDataBlock::operator=v null size\n"));
    267319T *p=Begin(), *pe=End();
    268320while (p<pe) *p++ = v;
    269321return *this;
     322}
     323
     324template <class T>
     325T NDataBlock<T>::Sum(size_t i1,size_t n) const
     326// Somme des elements de i1 a i1+n-1
     327{
     328if(i1>=mSz) return 0;
     329if(n>mSz) n = mSz; if(n==0) n = mSz-i1;
     330T const *p=Begin()+i1, *pe=p+n;
     331T val = 0;
     332while (p<pe) val += *p++;
     333return val;
     334}
     335
     336template <class T>
     337T NDataBlock<T>::Product(size_t i1,size_t n) const
     338// Produit des elements de i1 a i1+n-1
     339{
     340if(i1>=mSz) return 0;
     341if(n>mSz) n = mSz; if(n==0) n = mSz-i1;
     342T const *p=Begin()+i1, *pe=p+n;
     343T val = 0;
     344while (p<pe) val *= *p++;
     345return val;
    270346}
    271347
    … …  
    312388
    313389template <class T>
    314 NDataBlock<T>& NDataBlock<T>::operator += (NDataBlock<T>& a)
     390NDataBlock<T>& NDataBlock<T>::operator += (const NDataBlock<T>& a)
    315391{
    316392if(mSz==0 || mSz!=a.mSz)
    317393  throw(SzMismatchError("NDataBlock::operator+=A size mismatch/null"));
    318 T *p=Begin(), *pe=End(), *pa=a.Begin();
     394T *p=Begin(), *pe=End();
     395T const * pa=a.Begin();
    319396while (p<pe) *p++ += *pa++; // ca marche meme si *this=a
    320397return *this;
    … …  
    322399
    323400template <class T>
    324 NDataBlock<T>& NDataBlock<T>::operator -= (NDataBlock<T>& a)
     401NDataBlock<T>& NDataBlock<T>::operator -= (const NDataBlock<T>& a)
    325402{
    326403if(mSz==0 || mSz!=a.mSz)
    327404  throw(SzMismatchError("NDataBlock::operator-=A size mismatch/null"));
    328 T *p=Begin(), *pe=End(), *pa=a.Begin();
     405T *p=Begin(), *pe=End();
     406T const *pa=a.Begin();
    329407while (p<pe) *p++ -= *pa++; // ca marche meme si *this=a
    330408return *this;
    … …  
    332410
    333411template <class T>
    334 NDataBlock<T>& NDataBlock<T>::operator *= (NDataBlock<T>& a)
     412NDataBlock<T>& NDataBlock<T>::operator *= (const NDataBlock<T>& a)
    335413{
    336414if(mSz==0 || mSz!=a.mSz)
    337415  throw(SzMismatchError("NDataBlock::operator*=A size mismatch/null"));
    338 T *p=Begin(), *pe=End(), *pa=a.Begin();
     416T *p=Begin(), *pe=End();
     417T const *pa=a.Begin();
    339418while (p<pe) *p++ *= *pa++; // ca marche meme si *this=a
    340419return *this;
    … …  
    342421
    343422template <class T>
    344 NDataBlock<T>& NDataBlock<T>::operator /= (NDataBlock<T>& a)
     423NDataBlock<T>& NDataBlock<T>::operator /= (const NDataBlock<T>& a)
    345424{
    346425if(mSz==0 || mSz!=a.mSz)
    347426  throw(SzMismatchError("NDataBlock::operator/=A size mismatch/null"));
    348 T *p=Begin(), *pe=End(), *pa=a.Begin();
     427T *p=Begin(), *pe=End();
     428T const *pa=a.Begin();
    349429while (p<pe) *p++ /= *pa++;
    350430return *this;
    … …  
    355435
    356436template <class T>
    357 NDataBlock<T> NDataBlock<T>::Add(T b)
     437NDataBlock<T> NDataBlock<T>::Add(T b) const
    358438// Pour A+b
    359439{
    360 NDataBlock<T>& a = *this;
    361 NDataBlock<T> result(a,false); result.SetTemp(true);
    362 return result += b;
    363 }
    364 
    365 template <class T>
    366 NDataBlock<T> NDataBlock<T>::Sub(T b)
     440NDataBlock<T> result(*this,false); result.SetTemp(true);
     441result += b;
     442return result;
     443}
     444
     445template <class T>
     446NDataBlock<T> NDataBlock<T>::Sub(T b) const
    367447// Pour A-b
    368448{
    369 NDataBlock<T>& a = *this;
    370 NDataBlock<T> result(a,false); result.SetTemp(true);
     449NDataBlock<T> result(*this,false); result.SetTemp(true);
    371450return result -= b;
    372451}
    373452
    374453template <class T>
    375 NDataBlock<T> NDataBlock<T>::SubInv(T b)
     454NDataBlock<T> NDataBlock<T>::SubInv(T b) const
    376455// Pour b-A
    377456{
    378 NDataBlock<T>& a = *this;
    379 NDataBlock<T> result(a,false); result.SetTemp(true);
    380 T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
     457NDataBlock<T> result(*this,false); result.SetTemp(true);
     458T *p=result.Begin(), *pe=result.End();
     459T const *pa=this->Begin();
    381460while(p<pe) {*p++ = b - *pa++;}
    382461return result;
    … …  
    384463
    385464template <class T>
    386 NDataBlock<T> NDataBlock<T>::Mul(T b)
     465NDataBlock<T> NDataBlock<T>::Mul(T b) const
    387466// Pour A*b
    388467{
    389 NDataBlock<T>& a = *this;
    390 NDataBlock<T> result(a,false); result.SetTemp(true);
     468NDataBlock<T> result(*this,false); result.SetTemp(true);
    391469return result *= b;
    392470}
    393471
    394472template <class T>
    395 NDataBlock<T> NDataBlock<T>::Div(T b)
     473NDataBlock<T> NDataBlock<T>::Div(T b) const
    396474// Pour A/b
    397475{
    398 NDataBlock<T>& a = *this;
    399 NDataBlock<T> result(a,false); result.SetTemp(true);
     476NDataBlock<T> result(*this,false); result.SetTemp(true);
    400477return result /= b;
    401478}
    402479
    403480template <class T>
    404 NDataBlock<T> NDataBlock<T>::DivInv(T b)
     481NDataBlock<T> NDataBlock<T>::DivInv(T b) const
    405482// Pour b/A
    406483{
    407 NDataBlock<T>& a = *this;
    408 NDataBlock<T> result(a,false); result.SetTemp(true);
    409 T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
     484NDataBlock<T> result(*this,false); result.SetTemp(true);
     485T *p=result.Begin(), *pe=result.End();
     486T const *pa = this->Begin();
    410487while(p<pe) {*p++ = b / *pa++;}
    411488return result;
    … …  
    415492
    416493template <class T>
    417 NDataBlock<T> NDataBlock<T>::Add(NDataBlock<T>& b)
     494NDataBlock<T> NDataBlock<T>::Add(const NDataBlock<T>& b) const
    418495// Pour A+B
    419496{
    420 NDataBlock<T>& a = *this;
    421 if(a.mSz!=b.mSz)
     497if(this->mSz!=b.mSz)
    422498  throw(SzMismatchError("NDataBlock operator C=A+B size mismatch/null\n"));
     499NDataBlock<T> result; result.SetTemp(true);
    423500if(b.IsTemp()) {
    424   NDataBlock<T> result(b,true); result.SetTemp(true);
    425   return result += a;
     501  result.Share(b);
     502  result += *this;
    426503} else {
    427   NDataBlock<T> result(a,false); result.SetTemp(true);
    428   return result += b;
    429 }
    430 }
    431 
    432 template <class T>
    433 NDataBlock<T> NDataBlock<T>::Mul(NDataBlock<T>& b)
     504  result.Clone(*this);
     505  result += b;
     506}
     507return result;
     508}
     509
     510template <class T>
     511NDataBlock<T> NDataBlock<T>::Mul(const NDataBlock<T>& b) const
    434512// Pour A*B
    435513{
    436 NDataBlock<T>& a = *this;
    437 if(a.mSz!=b.mSz)
     514if(this->mSz!=b.mSz)
    438515  throw(SzMismatchError("NDataBlock operator C=A*B size mismatch/null\n"));
     516NDataBlock<T> result; result.SetTemp(true);
    439517if(b.IsTemp()) {
    440   NDataBlock<T> result(b,true); result.SetTemp(true);
    441   return result *= a;
     518  result.Share(b);
     519  result *= *this;
    442520} else {
    443   NDataBlock<T> result(a,false); result.SetTemp(true);
    444   return result *= b;
    445 }
    446 }
    447 
    448 template <class T>
    449 NDataBlock<T> NDataBlock<T>::Sub(NDataBlock<T>& b)
     521  result.Clone(*this);
     522  result *= b;
     523}
     524return result;
     525}
     526
     527template <class T>
     528NDataBlock<T> NDataBlock<T>::Sub(const NDataBlock<T>& b) const
    450529// Pour A-B
    451530{
    452 NDataBlock<T>& a = *this;
    453 if(a.mSz!=b.mSz)
     531if(this->mSz!=b.mSz)
    454532  throw(SzMismatchError("NDataBlock operator C=A-B size mismatch/null\n"));
     533NDataBlock<T> result; result.SetTemp(true);
    455534if(b.IsTemp()) {
    456   NDataBlock<T> result(b,true); result.SetTemp(true);
    457   T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
     535  result.Share(b);
     536  T *p=result.Begin(), *pe=result.End();
     537  T const *pa=this->Begin();
    458538  while(p<pe) {*p = *pa++  - *p; p++;}
    459   return result;
    460539} else {
    461   NDataBlock<T> result(a,false); result.SetTemp(true);
    462   return result -= b;
    463 }
    464 }
    465 
    466 template <class T>
    467 NDataBlock<T> NDataBlock<T>::Div(NDataBlock<T>& b)
     540  result.Clone(*this);
     541  result -= b;
     542}
     543return result;
     544}
     545
     546template <class T>
     547NDataBlock<T> NDataBlock<T>::Div(const NDataBlock<T>& b) const
    468548// Pour A/B
    469549{
    470 NDataBlock<T>& a = *this;
    471 if(a.mSz!=b.mSz)
     550if(this->mSz!=b.mSz)
    472551  throw(SzMismatchError("NDataBlock operator C=A/B size mismatch/null\n"));
     552NDataBlock<T> result; result.SetTemp(true);
    473553if(b.IsTemp()) {
    474   NDataBlock<T> result(b,true); result.SetTemp(true);
    475   T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
     554  result.Share(b);
     555  T *p=result.Begin(), *pe=result.End();
     556  T const *pa=this->Begin();
    476557  while(p<pe) {*p = *pa++  / *p; p++;}
    477   return result;
    478558} else {
    479   NDataBlock<T> result(a,false); result.SetTemp(true);
    480   return result /= b;
    481 }
     559  result.Clone(*this);
     560  result /= b;
     561}
     562return result;
    482563}
    483564
    … …  
    494575#pragma define_template NDataBlock<r_4>
    495576#pragma define_template NDataBlock<r_8>
    496 // pas de definitions de cout pour les complex ??
    497 //#pragma define_template NDataBlock< complex<float> >
    498 //#pragma define_template NDataBlock< complex<double> >
     577#pragma define_template NDataBlock< complex<float> >
     578#pragma define_template NDataBlock< complex<double> >
    499579#endif
    500580

  • trunk/SophyaLib/BaseTools/ndatablock.h

    r267 r268  
     1// This may look like C code, but it is really -*- C++ -*-
     2// Gestion de block de donnees avec partage de references
     3//                         C.Magneville          04/99
     4// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
    15#ifndef NDATABLOCK_H
    26#define NDATABLOCK_H
    37
    48#include "machdefs.h"
     9#include "anydataobj.h"
     10#include <iostream.h>
     11
     12namespace PlanckDPC {
    513
    614// Classe pour permettre de partager des donnees avec
    … …  
    1422// classe de container avec partage de reference
    1523template <class T>
    16 class NDataBlock {
     24class NDataBlock : public AnyDataObj {
    1725
    1826public:
    … …  
    2230  NDataBlock(size_t n, T* data, Bridge* br=NULL);
    2331  NDataBlock();
    24   NDataBlock(NDataBlock<T>& a);
    25   NDataBlock(NDataBlock<T>& a,bool share);
     32  NDataBlock(const NDataBlock<T>& a);
     33  NDataBlock(const NDataBlock<T>& a,bool share);
    2634  virtual ~NDataBlock();
    2735
    2836  // Temporaire?
    29   inline bool IsTemp(void) {return mIsTemp;}
    30   void SetTemp(bool temp=false);
     37  inline bool IsTemp(void) const {return mIsTemp;}
     38  void SetTemp(bool temp=false) const;
    3139
    3240  // Gestion taille/Remplissage
    33   void Clone(NDataBlock<T>& a);
     41  void Clone(const NDataBlock<T>& a);
    3442  void Reset(T v=0);
    3543  void ReSize(size_t n);
    … …  
    3947  inline T* Data()
    4048         {if(mSRef) return mSRef->data; else return NULL;}
     49  inline T* Data() const
     50         {if(mSRef) return mSRef->data; else return NULL;}
    4151  inline size_t Size() const    {return mSz;}
    42   inline T& operator()(size_t i) {return *(mSRef->data+i);}
     52  inline T& operator()(size_t i)       {return *(mSRef->data+i);}
     53  inline T  operator()(size_t i) const {return *(mSRef->data+i);}
    4354
    4455  inline T*        Begin()        {return mSRef->data;}
    45   inline T const*  Begin() const  {return mSRef->data;}
     56  inline T const*  Begin() const  {return mSRef->data;} 
    4657  inline T*        End()          {return mSRef->data+mSz;}
    4758  inline T const*  End() const    {return mSRef->data+mSz;}
    4859
    4960  // Impression
    50   void Print(size_t i1=0,size_t n=0);
     61  void Print(ostream& os, size_t i1=0,size_t n=10) const;
     62  inline void Print(size_t i1=0,size_t n=0) const {Print(cout,i1,n);}
     63
     64  //
     65  T Sum(size_t i1=0,size_t n=0) const;
     66  T Product(size_t i1=0,size_t n=0) const;
    5167
    5268  // Surcharge d operateurs
    53   NDataBlock<T>& operator = (NDataBlock<T>& a);
     69  NDataBlock<T>& operator = (const NDataBlock<T>& a);
    5470  NDataBlock<T>& operator = (T v);
    5571
    … …  
    5975  NDataBlock<T>& operator /= (T b);
    6076
    61   NDataBlock<T>& operator += (NDataBlock<T>& a);
    62   NDataBlock<T>& operator -= (NDataBlock<T>& a);
    63   NDataBlock<T>& operator *= (NDataBlock<T>& a);
    64   NDataBlock<T>& operator /= (NDataBlock<T>& a);
     77  NDataBlock<T>& operator += (const NDataBlock<T>& a);
     78  NDataBlock<T>& operator -= (const NDataBlock<T>& a);
     79  NDataBlock<T>& operator *= (const NDataBlock<T>& a);
     80  NDataBlock<T>& operator /= (const NDataBlock<T>& a);
    6581
    66   NDataBlock<T> Add(T b);
    67   NDataBlock<T> Sub(T b);
    68   NDataBlock<T> SubInv(T b);
    69   NDataBlock<T> Mul(T b);
    70   NDataBlock<T> Div(T b);
    71   NDataBlock<T> DivInv(T b);
     82  NDataBlock<T> Add(T b) const;
     83  NDataBlock<T> Sub(T b) const;
     84  NDataBlock<T> SubInv(T b) const;
     85  NDataBlock<T> Mul(T b) const;
     86  NDataBlock<T> Div(T b) const;
     87  NDataBlock<T> DivInv(T b) const;
    7288
    73   NDataBlock<T> Add(NDataBlock<T>& b);
    74   NDataBlock<T> Sub(NDataBlock<T>& b);
    75   NDataBlock<T> SubInv(NDataBlock<T>& b);
    76   NDataBlock<T> Mul(NDataBlock<T>& b);
    77   NDataBlock<T> Div(NDataBlock<T>& b);
    78   NDataBlock<T> DivInv(NDataBlock<T>& b);
     89  NDataBlock<T> Add(const NDataBlock<T>& b) const;
     90  NDataBlock<T> Sub(const NDataBlock<T>& b) const;
     91  NDataBlock<T> SubInv(const NDataBlock<T>& b) const;
     92  NDataBlock<T> Mul(const NDataBlock<T>& b) const;
     93  NDataBlock<T> Div(const NDataBlock<T>& b) const;
     94  NDataBlock<T> DivInv(const NDataBlock<T>& b) const;
    7995
    8096protected:
    … …  
    8399
    84100  void Alloc(size_t n,T* data=NULL,Bridge* br=NULL);
    85   void Share(NDataBlock<T>& a);
     101  void Share(const NDataBlock<T>& a);
    86102  void Delete(void);
    87103
    88104  size_t   mSz;
    89105  NDREF*   mSRef;
    90   bool     mIsTemp;
     106  mutable bool     mIsTemp;
    91107};
    92108
    93109
    94110template<class T>
    95 inline NDataBlock<T> operator + (NDataBlock<T>& a,T b)
     111inline ostream& operator << (ostream& os, const NDataBlock<T>& a)
     112                      {Print(os); return(os);}
     113template<class T>
     114inline NDataBlock<T> operator + (const NDataBlock<T>& a,T b)
    96115                      {return a.Add(b);}
    97116template<class T>
    98 inline NDataBlock<T> operator + (T b,NDataBlock<T>& a)
     117inline NDataBlock<T> operator + (T b,const NDataBlock<T>& a)
    99118                      {return a.Add(b);}
    100119template<class T>
    101 inline NDataBlock<T> operator - (NDataBlock<T>& a,T b)
     120inline NDataBlock<T> operator - (const NDataBlock<T>& a,T b)
    102121                      {return a.Sub(b);}
    103122template<class T>
    104 inline NDataBlock<T> operator - (T b,NDataBlock<T>& a)
     123inline NDataBlock<T> operator - (T b,const NDataBlock<T>& a)
    105124                      {return a.SubInv(b);}
    106125template<class T>
    107 inline NDataBlock<T> operator * (NDataBlock<T>& a,T b)
     126inline NDataBlock<T> operator * (const NDataBlock<T>& a,T b)
    108127                      {return a.Mul(b);}
    109128template<class T>
    110 inline NDataBlock<T> operator * (T b,NDataBlock<T>& a)
     129inline NDataBlock<T> operator * (T b,const NDataBlock<T>& a)
    111130                      {return a.Mul(b);}
    112131template<class T>
    113 inline NDataBlock<T> operator / (NDataBlock<T>& a,T b)
     132inline NDataBlock<T> operator / (const NDataBlock<T>& a,T b)
    114133                      {return a.Div(b);}
    115134template<class T>
    116 inline NDataBlock<T> operator / (T b,NDataBlock<T>& a)
     135inline NDataBlock<T> operator / (T b,const NDataBlock<T>& a)
    117136                      {return a.DivInv(b);}
    118137
    119138template<class T>
    120 inline NDataBlock<T> operator + (NDataBlock<T>& a,NDataBlock<T>& b)
     139inline NDataBlock<T> operator + (const NDataBlock<T>& a,const NDataBlock<T>& b)
    121140                      {return a.Add(b);}
    122141template<class T>
    123 inline NDataBlock<T> operator - (NDataBlock<T>& a,NDataBlock<T>& b)
     142inline NDataBlock<T> operator - (const NDataBlock<T>& a,const NDataBlock<T>& b)
    124143                      {return a.Sub(b);}
    125144template<class T>
    126 inline NDataBlock<T> operator * (NDataBlock<T>& a,NDataBlock<T>& b)
     145inline NDataBlock<T> operator * (const NDataBlock<T>& a,const NDataBlock<T>& b)
    127146                      {return a.Mul(b);}
    128147template<class T>
    129 inline NDataBlock<T> operator / (NDataBlock<T>& a,NDataBlock<T>& b)
     148inline NDataBlock<T> operator / (const NDataBlock<T>& a,const NDataBlock<T>& b)
    130149                      {return a.Div(b);}
    131150
     151} // Fin du namespace
    132152
    133153#endif
Note: See TracChangeset for help on using the changeset viewer.