Changeset 976 in Sophya


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

modifs doc cmv 27/4/00

Location:
trunk/SophyaLib
Files:
11 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

  • trunk/SophyaLib/Manual/dox_sophya.conf

    r916 r976  
    1616# if some version control system is used.
    1717
    18 PROJECT_NUMBER       = 0.9.36 V_Avr2000
     18PROJECT_NUMBER       =
    1919
    2020# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
    … …  
    191191# with spaces.
    192192
    193 INPUT = ../SysTools ../TArray ../NTools ../HiStats
     193INPUT =
    194194
    195195# If the value of the INPUT tag contains directories, you can use the
    … …  
    222222# the \include command).
    223223
    224 EXAMPLE_PATH         = ../SysTools ../TArray ../NTools
     224EXAMPLE_PATH         =
    225225
    226226# If the value of the EXAMPLE_PATH tag contains directories, you can use the

  • trunk/SophyaLib/Manual/mkmf

    r891 r976  
    11#!/bin/csh
    2 ###################################################
     2#####################################################
    33if( $#argv >= 1 ) then
    44  if( "$1" == "-h" ) then
    5     echo "mkmf [module1] [module2] [...]"
     5    echo "mkmf [-options] [-o dir] [module1] [module2] [...]"
    66    echo "  generate documentation for all Sophya"
    7     echo "  or only for module [module]"
    8     exit 0
     7    echo "  or only for module [module...]"
     8    echo "  **** [-options] :"
     9    echo "  -html : generate HTML doc"
     10    echo "  -latex : generate LATEX doc"
     11    echo "  -man : generate MAN doc"
     12    echo "  -rtf : generate RTF doc"
     13    echo "  default is : html + latex"
     14    echo "  **** [-o dir] : directory where doc have to be put"
     15    echo "  default is ."
     16    exit -1
    917  endif
     18endif
     19#####################################################
     20
     21##################################
     22######## Decode arguments ########
     23##################################
     24set allmodules = ( SysTools TArray NTools HiStats )
     25unset modules; unset latex; unset html; unset man; unset rtf
     26set outdir = "."
     27if( $#argv >= 1 ) then
     28  while ( $#argv > 0)
     29    if( "$1" == "-o" ) then
     30      shift
     31      set outdir = $1
     32    else if( "$1" == "-html" ) then
     33      set html
     34    else if( "$1" == "-latex" ) then
     35      set latex
     36    else if( "$1" == "-man" ) then
     37      set man
     38    else if( "$1" == "-rtf" ) then
     39      set rtf
     40    else
     41      if( ! $?modules ) set modules
     42      set modules = ( $modules $1 )
     43    endif
     44    shift
     45  end
     46endif
     47if( ! $?html  && ! $?latex  && ! $?man  && ! $?rtf ) then
     48  set html
     49  set latex
     50endif
     51if( ! $?modules ) then
     52  set modules = ( $allmodules )
    1053endif
    1154
    … …  
    1457##########################################
    1558
     59#------------
    1660# mydoxy.conf
     61#------------
    1762cp dox_sophya.conf mydoxy.conf
    18 foreach n ( 1 2 3 4 5 )
    19   echo " " >> mydoxy.conf
    20 end
    2163
     64#----------
    2265# doxygen ?
     66#----------
    2367which doxygen >! /dev/null
    2468if( $status != 0 ) then
    … …  
    2771endif
    2872
     73#-------------
    2974# doxysearch ?
     75#-------------
    3076which doxysearch >! /dev/null
    3177if( $status != 0 ) then
    … …  
    3480else
    3581    set s = `which doxysearch`
    36   echo 'doxysearch is installed in :'
    37   echo $s:h
     82  echo 'doxysearch is installed in : ' $s:h
    3883  echo 'mkmf will automatically update the config file.'
    3984    echo "BIN_ABSPATH = $s:h" >>  mydoxy.conf
    … …  
    4186endif
    4287
    43 # partial doc ?
    44 if( $#argv >= 1 ) then
    45   echo Partial doc generation :
    46     set lf =
    47     foreach f ( $* )
    48       echo "... adding ../$f to INPUT"
    49       set lf = ( ../$f $lf )
    50     end
    51     echo "INPUT = $lf" >>  mydoxy.conf
    52     grep 'INPUT = ' mydoxy.conf | grep -v ^\# | tail -1
     88#-----------------
     89# Version number ?
     90#-----------------
     91set f = ../SysTools/sversion.h
     92if( -e $f ) then
     93  set v = `grep 'SOPHYA_VERSION'  $f | awk '{print $3}'`
     94  set r = `grep 'SOPHYA_REVISION' $f | awk '{print $3}'`
     95  set t = `grep 'SOPHYA_TAG'      $f | awk '{print $3}'`
     96  echo "PROJECT_NUMBER = V${v}_R${r}_${t}" >>  mydoxy.conf
     97else
     98  echo "PROJECT_NUMBER = Not_Defined" >>  mydoxy.conf
    5399endif
     100grep 'PROJECT_NUMBER = ' mydoxy.conf | tail -1
     101
     102#---------------
     103# What modules ?
     104#---------------
     105set lf =
     106foreach f ( $modules )
     107  echo "... Generating doc for ../$f"
     108  set lf = ( ../$f $lf )
     109end
     110echo "INPUT = $lf" >>  mydoxy.conf
     111grep 'INPUT = ' mydoxy.conf | tail -1
     112
     113set lf =
     114foreach f ( $allmodules )
     115  set lf = ( ../$f $lf )
     116end
     117echo "EXAMPLE_PATH = $lf" >>  mydoxy.conf
     118
     119#-------------------
     120# What kind of doc ?
     121#-------------------
     122if( $?html ) then
     123  echo "GENERATE_HTML = YES" >>  mydoxy.conf
     124  echo "...... generating HTML"
     125else
     126  echo "GENERATE_HTML = NO" >>  mydoxy.conf
     127endif
     128if( $?latex ) then
     129  echo "GENERATE_LATEX = YES" >>  mydoxy.conf
     130  echo "...... generating LATEX"
     131else
     132  echo "GENERATE_LATEX = NO" >>  mydoxy.conf
     133endif
     134if( $?man ) then
     135  echo "GENERATE_MAN = YES" >>  mydoxy.conf
     136  echo "...... generating MAN"
     137else
     138  echo "GENERATE_MAN = NO" >>  mydoxy.conf
     139endif
     140if( $?rtf ) then
     141  echo "GENERATE_RTF = YES" >>  mydoxy.conf
     142  echo "...... generating RTF"
     143else
     144  echo "GENERATE_RTF = NO" >>  mydoxy.conf
     145endif
     146
     147#------------------------
     148# What output directory ?
     149#------------------------
     150echo "OUTPUT_DIRECTORY = $outdir" >>  mydoxy.conf
     151grep 'OUTPUT_DIRECTORY = ' mydoxy.conf | tail -1
     152
     153#--------------------------
     154# Configuration file update
     155#--------------------------
     156doxygen -u mydoxy.conf >! /dev/null
     157rm -f mydoxy.conf.bak
    54158
    55159#########################################

  • trunk/SophyaLib/TArray/sopemtx.cc

    r939 r976  
    539539TMatrix<T> SimpleMatrixOperation<T>::Inverse(TMatrix<T> const & A)
    540540{
    541 TMatrix<T> a(A);
     541TMatrix<T> a(A,false);
    542542TMatrix<T> b(a.NCols(),a.NRows());  b = IdentityMatrix(1.);
    543543if( TMatrixRC<T>::Abs_Value(GausPiv(a,b)) < 1.e-50)
    544544  throw(MathExc("TMatrix Inverse() Singular Matrix"));
     545b.SetTemp(true);
    545546return b;
    546547}

  • trunk/SophyaLib/TArray/tarray.cc

    r970 r976  
    105105
    106106//! Constructor by copy
    107 /*! \sa NDataBlock::NDataBlock(const NDataBlock<T>&) */
     107/*!
     108  \warning datas are \b SHARED with \b a.
     109  \sa NDataBlock::NDataBlock(const NDataBlock<T>&)
     110 */
    108111template <class T>
    109112TArray<T>::TArray(const TArray<T>& a)
    … …  
    137140
    138141//! Set array equal to \b a and return *this
     142/*!
     143  \warning Datas are copied (cloned) from \b a.
     144  \sa NDataBlock::operator=(const NDataBlock<T>&)
     145*/
    139146template <class T>
    140147TArray<T>& TArray<T>::Set(const TArray<T>& a)
    … …  
    160167
    161168//! Clone if \b a is not temporary, share if temporary
     169/*! \sa NDataBlock::CloneOrShare(const NDataBlock<T>&) */
    162170template <class T>
    163171void TArray<T>::CloneOrShare(const TArray<T>& a)

  • trunk/SophyaLib/TArray/tarray.h

    r970 r976  
    4040  // A = B
    4141  //! = operator between TArray
    42   /*! \sa Set \sa NDataBlock::operator=(const NDataBlock<T>&) */
     42  /*! \warning Datas are copied (cloned) from \b a.
     43      \sa Set \sa NDataBlock::operator=(const NDataBlock<T>&) */
    4344  inline  TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
    4445  virtual TArray<T>& Set(const TArray<T>& a);

  • trunk/SophyaLib/TArray/tmatrix.cc

    r970 r976  
    1 // $Id: tmatrix.cc,v 1.10 2000-04-26 17:55:10 ansari Exp $
     1// $Id: tmatrix.cc,v 1.11 2000-04-27 17:53:51 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    4343
    4444//! Constructor by copy
    45 /*! \sa NDataBlock::NDataBlock(const NDataBlock<T>&) */
     45/*!
     46  \warning datas are \b SHARED with \b a.
     47  \sa NDataBlock::NDataBlock(const NDataBlock<T>&)
     48*/
    4649template <class T>
    4750TMatrix<T>::TMatrix(const TMatrix<T>& a)
    … …  
    103106}
    104107
    105 //! Set matirx equal to \b a and return *this
     108//! Set matrix equal to \b a and return *this
     109/*!
     110  \warning Datas are copied (cloned) from \b a.
     111  \sa NDataBlock::operator=(const NDataBlock<T>&)
     112*/
    106113template <class T>
    107114TArray<T>& TMatrix<T>::Set(const TArray<T>& a)

  • trunk/SophyaLib/TArray/tmatrix.h

    r970 r976  
    2525  virtual TArray<T>& Set(const TArray<T>& a);
    2626  //! Operator = between matrices
    27   /*! \sa NDataBlock::operator=(const NDataBlock<T>&) */
     27  /*! \warning Datas are copied (cloned) from \b a.
     28      \sa NDataBlock::operator=(const NDataBlock<T>&) */
    2829  inline  TMatrix<T>& operator = (const TMatrix<T>& a)
    2930                     { Set(a);  return(*this); }

  • trunk/SophyaLib/TArray/tvector.cc

    r967 r976  
    1 // $Id: tvector.cc,v 1.7 2000-04-21 16:31:26 ansari Exp $
     1// $Id: tvector.cc,v 1.8 2000-04-27 17:53:52 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    4040
    4141//! Constructor by copy
    42 /*! \sa NDataBlock::NDataBlock(const NDataBlock<T>&) */
     42/*!
     43  \warning datas are \b SHARED with \b a.
     44  \sa NDataBlock::NDataBlock(const NDataBlock<T>&)
     45*/
    4346template <class T>
    4447TVector<T>::TVector(const TVector<T>& a)

  • trunk/SophyaLib/TArray/tvector.h

    r967 r976  
    2323
    2424  //! Operator =
    25   /*! \sa NDataBlock::operator=(const NDataBlock<T>&) */
     25  /*! \warning Datas are copied (cloned) from \b a.
     26      \sa NDataBlock::operator=(const NDataBlock<T>&) */
    2627  inline  TVector<T>& operator = (const TVector<T>& a)
    2728                       { Set(a);  return(*this); }
Note: See TracChangeset for help on using the changeset viewer.