Changeset 976 in Sophya for trunk/SophyaLib/BaseTools


Ignore:
Timestamp:
Apr 27, 2000, 7:55:14 PM (25 years ago)
Author:
ansari
Message:

modifs doc cmv 27/4/00

Location:
trunk/SophyaLib/BaseTools
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/BaseTools/ndatablock.cc

    r969 r976  
    114114//! Copy constructor
    115115/*!
    116   \warning datas are shared if \b a is temporary, cloned if not.
     116  \warning datas are \b SHARED with \b a.
    117117 */
    118118template <class T>
    … …  
    199199
    200200//! \b Share with \b a if \b temporary, \b clone from \b a if not.
     201/*! \warning For most purposes, users don't have to worry with
     202             the "temporary" nature of a NDataBlock. That is used
     203             internaly to avoid memory allocation in operation
     204             like A = B + C + D for instance. The method is not
     205             protected to allow users to write complicated functions
     206             on NDataBlock.
     207  \verbatim
     208  ----------------------------------------------------------
     209  Pourquoi une complication avec la notion de "temporaire" :
     210  ----------------------------------------------------------
     211  - Le constructeur par copie partageant les donnees,
     212    dans une methode un { NDataBlock<T> result; ...; return result;}
     213    ne va pas allouer de la memoire pour retourner "result".
     214  - La gestion de temporaire sert quand on enchaine plusieurs
     215    operations sur la meme ligne, par exemple : A = B+C+D;
     216    Dans ce cas l'objet CD=C+D est d'abord alloue et rempli
     217    avec C+D, puis CD est mis a "temporaire".
     218    Quand on ajoute B a CD, la methode d'addition va se rendre compte
     219    que CD est "temporaire" et additionner B "in-place" dans CD
     220    sans allouer une fois de plus de la place (pas d'allocation
     221    de place BCD pour mettre B+CD mais une operation CD += B).
     222    Si la notion d'objet "temporaire" n'avait pas ete consideree
     223    l'addition A = B+C+D aurait alloue de la place pour "CD=C+D"
     224    puis pour BCD=B+CD : 2 allocations auraient ete necessaires
     225    contre 1 seule dans notre cas de geston de "temporaire".
     226  \endverbatim
     227*/
    201228template <class T>
    202229void NDataBlock<T>::CloneOrShare(const NDataBlock<T>& a)
    … …  
    473500///////////////////////////////////////////////////////////////
    474501
    475 //! Operator = : ND = ND1
    476 /*! \warning share if \b a is temporary, clone if not */
     502//! Operator = : ND = NDa
     503/*! \warning Datas are copied (cloned) from \b a. */
    477504template <class T>
    478505NDataBlock<T>& NDataBlock<T>::operator = (const NDataBlock<T>& a)
    … …  
    487514if(a.mSz==0)
    488515  throw(SzMismatchError("NDataBlock::operator=A null size \n"));
    489 if (mSz==0) { 
    490   CloneOrShare(a);
    491   return *this;
    492 }
     516if (mSz==0) { CloneOrShare(a); return *this; }
    493517if (a.mSz != mSz)
    494518  throw(SzMismatchError("NDataBlock::operator=A Unequal sizes \n"));
    … …  
    506530      <<" mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
    507531
    508 
    509532if(mSz==0) throw(SzMismatchError("NDataBlock::operator=v null size\n"));
    510 T *p=Begin(), *pe=End();
    511 while (p<pe) *p++ = v;
     533T *p=Begin(), *pe=End(); while (p<pe) *p++ = v;
    512534return *this;
    513535}
    … …  
    522544{
    523545if(mSz==0) throw(SzMismatchError("NDataBlock::operator+=v null size\n"));
    524 T *p=Begin(), *pe=End();
    525 while (p<pe) *p++ += b;
     546T *p=Begin(), *pe=End(); while (p<pe) *p++ += b;
    526547return *this;
    527548}
    … …  
    532553{
    533554if(mSz==0) throw(SzMismatchError("NDataBlock::operator-=v null size\n"));
    534 T *p=Begin(), *pe=End();
    535 while (p<pe) *p++ -= b;
     555T *p=Begin(), *pe=End(); while (p<pe) *p++ -= b;
    536556return *this;
    537557}
    … …  
    542562{
    543563if(mSz==0) throw(SzMismatchError("NDataBlock::operator*=v null size\n"));
    544 T *p=Begin(), *pe=End();
    545 while (p<pe) *p++ *= b;
    546 return *this;
    547 }
    548 
    549 //! Divide by a constant : ND *= b
     564T *p=Begin(), *pe=End(); while (p<pe) *p++ *= b;
     565return *this;
     566}
     567
     568//! Divide by a constant : ND /= b
    550569template <class T>
    551570NDataBlock<T>& NDataBlock<T>::operator /= (T b)
    … …  
    553572if(b==(T) 0) throw(ParmError("NDataBlock::operator/=v divide by zero\n"));
    554573if(mSz==0) throw(SzMismatchError("NDataBlock::operator/=v null size\n"));
    555 T *p=Begin(), *pe=End();
    556 while (p<pe) *p++ /= b;
     574T *p=Begin(), *pe=End(); while (p<pe) *p++ /= b;
    557575return *this;
    558576}
    … …  
    562580////////////////////////////////////////////////////////////////////
    563581
    564 //! Add a NDataBlock : ND += ND1
     582//! Add a NDataBlock : ND += NDa
    565583template <class T>
    566584NDataBlock<T>& NDataBlock<T>::operator += (const NDataBlock<T>& a)
    … …  
    574592}
    575593
    576 //! Substract a NDataBlock : ND -= ND1
     594//! Substract a NDataBlock : ND -= NDa
    577595template <class T>
    578596NDataBlock<T>& NDataBlock<T>::operator -= (const NDataBlock<T>& a)
    … …  
    586604}
    587605
    588 //! Multiply by a NDataBlock : ND *= ND1
     606//! Multiply by a NDataBlock : ND *= NDa
    589607template <class T>
    590608NDataBlock<T>& NDataBlock<T>::operator *= (const NDataBlock<T>& a)
    … …  
    598616}
    599617
    600 //! Divide by a NDataBlock : ND *= ND1
     618//! Divide by a NDataBlock : ND /= NDa
    601619template <class T>
    602620NDataBlock<T>& NDataBlock<T>::operator /= (const NDataBlock<T>& a)
    … …  
    607625T *p=Begin(), *pe=End();
    608626T const *pa=a.Begin();
    609 while (p<pe) *p++ /= *pa++;
    610 return *this;
    611 }
    612 
    613 ////////////////////////////////////////////////////////////////
    614 // Pour surcharge de +,-,*,/ : NDataBlock = NDataBlock1+<T>b; //
    615 //                             NDataBlock = <T>b+NDataBlock1; //
    616 ////////////////////////////////////////////////////////////////
     627while (p<pe) *p++ /= *pa++; // Division par zero non protegee
     628return *this;
     629}
     630
     631//////////////////////////////////////////////////////////////////
     632// Pour surcharge de +,-,*,/ : NDataBlock = NDataBlock1+<T>b;   //
     633//                             NDataBlock = <T>b+NDataBlock1;   //
     634// Pour la notion de "temporaire" voir blabla dans CloneOrShare //
     635//////////////////////////////////////////////////////////////////
    617636
    618637//! Add a constant and return NDataBlock : NDret = ND + b
    … …  
    627646}
    628647
    629 //! Substract a constant and return NDataBlock : NDret = ND - b
    630 template <class T>
    631 NDataBlock<T> NDataBlock<T>::Sub(T b) const
    632 // Pour A-b
     648//! Substract a constant and return NDataBlock : NDret = ND - b or NDret = b - ND
     649/*! Substract a constant or from a constant
     650   \param fginv==false : performs NDret = ND - b (default)
     651   \param fginv==true : performs NDret = b - ND
     652*/
     653template <class T>
     654NDataBlock<T> NDataBlock<T>::Sub(T b,bool fginv) const
     655// Pour A-b sauf si fginv==true b-A (- n'est pas commutatif!)
    633656{
    634657NDataBlock<T> result;
    635658result.CloneOrShare(*this); result.SetTemp(true);
    636 return result -= b;
    637 }
    638 
    639 //! Substract from a constant and return NDataBlock : NDret = b - ND
    640 template <class T>
    641 NDataBlock<T> NDataBlock<T>::SubInv(T b) const
    642 // Pour b-A
     659if(fginv) {
     660  T *p=result.Begin(), *pe=result.End();
     661  T const *pa=this->Begin();
     662  while(p<pe) {*p++ = b - *pa++;}
     663} else result -= b;
     664return result;
     665}
     666
     667//! Multiply by a constant and return NDataBlock : NDret = ND * b
     668template <class T>
     669NDataBlock<T> NDataBlock<T>::Mul(T b) const
     670// Pour A*b
    643671{
    644672NDataBlock<T> result;
    645673result.CloneOrShare(*this); result.SetTemp(true);
    646 T *p=result.Begin(), *pe=result.End();
    647 T const *pa=this->Begin();
    648 while(p<pe) {*p++ = b - *pa++;}
     674result *= b;
    649675return result;
    650676}
    651677
    652 //! Multiply by a constant and return NDataBlock : NDret = ND * b
    653 template <class T>
    654 NDataBlock<T> NDataBlock<T>::Mul(T b) const
    655 // Pour A*b
     678//! Divide by a constant and return NDataBlock : NDret = ND / b or NDret = b / ND
     679/*! Divide by a constant or from a constant
     680   \param fginv==false : performs NDret = ND / b (default)
     681   \param fginv==true : performs NDret = b / ND
     682*/
     683template <class T>
     684NDataBlock<T> NDataBlock<T>::Div(T b,bool fginv) const
     685// Pour A/b sauf si fginv==true b/A (/ n'est pas commutatif!)
    656686{
    657687NDataBlock<T> result;
    658688result.CloneOrShare(*this); result.SetTemp(true);
    659 return result *= b;
    660 }
    661 
    662 //! Divide by a constant and return NDataBlock : NDret = ND / b
    663 template <class T>
    664 NDataBlock<T> NDataBlock<T>::Div(T b) const
    665 // Pour A/b
    666 {
    667 NDataBlock<T> result;
    668 result.CloneOrShare(*this); result.SetTemp(true);
    669 return result /= b;
    670 }
    671 
    672 //! Divide from a constant and return NDataBlock : NDret = b / ND
    673 template <class T>
    674 NDataBlock<T> NDataBlock<T>::DivInv(T b) const
    675 // Pour b/A
    676 {
    677 NDataBlock<T> result;
    678 result.CloneOrShare(*this); result.SetTemp(true);
    679 T *p=result.Begin(), *pe=result.End();
    680 T const *pa = this->Begin();
    681 while(p<pe) {*p++ = b / *pa++;}
     689 if(fginv) {
     690  T *p=result.Begin(), *pe=result.End();
     691  T const *pa = this->Begin();
     692  while(p<pe) {*p++ = b / *pa++;} // Division par zero non protegee
     693} else {
     694  if( b == (T) 0 ) throw MathExc("NDataBlock<T>::Div(T)  - Divide by zero ! ");
     695  result /= b;
     696}
    682697return result;
    683698}
    … …  
    740755  result.Share(b);
    741756  T *p=result.Begin(), *pe=result.End(); T const *pa=Begin();
    742   while(p<pe) {*p = *pa++  / *p; p++;}
     757  while(p<pe) {*p = *pa++  / *p; p++;} // Division par zero non protegee
    743758} else {result.CloneOrShare(*this); result /= b;}
    744759return result;

  • trunk/SophyaLib/BaseTools/ndatablock.h

    r948 r976  
    133133  // Surcharge d'operateurs: C = A @ x , C = A @ B
    134134  NDataBlock<T> Add(T b) const;
    135   NDataBlock<T> Sub(T b) const;
    136   NDataBlock<T> SubInv(T b) const;
     135  NDataBlock<T> Sub(T b,bool fginv=false) const;
    137136  NDataBlock<T> Mul(T b) const;
    138   NDataBlock<T> Div(T b) const;
    139   NDataBlock<T> DivInv(T b) const;
     137  NDataBlock<T> Div(T b,bool fginv=false) const;
    140138
    141139  NDataBlock<T> Add(const NDataBlock<T>& b) const;
    142140  NDataBlock<T> Sub(const NDataBlock<T>& b) const;
    143   NDataBlock<T> SubInv(const NDataBlock<T>& b) const;
    144141  NDataBlock<T> Mul(const NDataBlock<T>& b) const;
    145142  NDataBlock<T> Div(const NDataBlock<T>& b) const;
    146   NDataBlock<T> DivInv(const NDataBlock<T>& b) const;
    147143
    148144protected:
    … …  
    186182template<class T>
    187183inline NDataBlock<T> operator - (T b,const NDataBlock<T>& a)
    188                       {return a.SubInv(b);}
     184                      {return a.Sub(b,true);}
    189185//! Multiply datas by a constant and return NDataBlock : ND = NDa * b
    190186template<class T>
    … …  
    202198template<class T>
    203199inline NDataBlock<T> operator / (T b,const NDataBlock<T>& a)
    204                       {return a.DivInv(b);}
     200                      {return a.Div(b,true);}
    205201
    206202//! Add datas of two data blocks and return NDataBlock : ND = NDa + NDb
Note: See TracChangeset for help on using the changeset viewer.