Changeset 894 in Sophya for trunk/SophyaLib/TArray/tarray.h


Ignore:
Timestamp:
Apr 12, 2000, 7:42:33 PM (25 years ago)
Author:
ansari
Message:

documentation cmv 12/4/00

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/TArray/tarray.h

    r813 r894  
    2323//  ( See BaseArray class for data organisation in  memory and related methods )
    2424
     25//! Class for template arrays
     26/*!
     27  This class implements arrays of dimensions up to
     28  \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS"
     29*/
    2530template <class T>
    2631class TArray : public BaseArray {
    … …  
    3843
    3944  // A = B : partage les donnees si "a" est temporaire, clone sinon.
     45  //! = operator between TArray
     46  /*! \sa Set */
    4047  inline  TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
    4148  virtual TArray<T>& Set(const TArray<T>& a);
    … …  
    5461
    5562  // SubArrays - $CHECK$ Reza 03/2000 je ne sais pas s'il faut declarer ca const ??
    56   TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ;
     63  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ;
     64  //! () operator for Sub arrays extraction
     65  /*! \sa SubArray */
    5766  inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt=0, Range ru=0) const
    5867                   { return  SubArray(rx, ry, rz, rt, ru); }
    … …  
    7584  inline T&       ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
    7685
     86  //! Return pointer to first element adress
    7787  inline        T* Data()       {return mNDBlock.Begin()+offset_;}
     88  //! Return pointer to first element adress
    7889  inline const  T* Data() const {return mNDBlock.Begin()+offset_;}
     90  //! Return reference to datablock NDataBlock
    7991  inline        NDataBlock<T>& DataBlock()       {return mNDBlock;}
     92  //! Return reference to datablock NDataBlock
    8093  inline const  NDataBlock<T>& DataBlock() const {return mNDBlock;}
    8194
    8295  // Temporaire?
     96  //! Are the array temporay ?
    8397  inline bool   IsTemp(void) const {return mNDBlock.IsTemp();}
     98  //! Set the array as temporay
    8499  inline void   SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
    85100
    … …  
    89104// Met les elements a une suite de valeurs
    90105  virtual TArray<T>&  SetSeq(Sequence seq);
     106  //! Fill TArray with Sequence \b seq
    91107  inline  TArray<T>&  operator = (Sequence seq)    { return SetSeq(seq); }
    92108// A = x (tous les elements a x)
    93109  virtual TArray<T>&  SetT(T x);
     110  //! Fill TArray with all elements equal to \b x
    94111  inline  TArray<T>&  operator = (T x)             { return SetT(x); }
    95112// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
    96113  virtual TArray<T>&  Add(T x);
     114  //! Add \b x to all elements
    97115  inline  TArray<T>&  operator += (T x)            { return Add(x); }
    98116  virtual TArray<T>&  Sub(T x);
     117  //! Substract \b x to all elements
    99118  inline  TArray<T>&  operator -= (T x)            { return Sub(x); }
    100119  virtual TArray<T>&  Mul(T x);
     120  //! Multiply all elements by \b x
    101121  inline  TArray<T>&  operator *= (T x)            { return Mul(x); }
    102122  virtual TArray<T>&  Div(T x);
     123  //! Divide all elements by \b x
    103124  inline  TArray<T>&  operator /= (T x)            { return Div(x); }
    104125  virtual TArray<T>&  SubInv(T x);  //   A ---> x-A
    … …  
    107128// A += -=  (ajoute, soustrait element par element les deux tableaux )
    108129  virtual TArray<T>&  AddElt(const TArray<T>& a);
     130  //! Operator TArray += TArray
    109131  inline  TArray<T>&  operator += (const TArray<T>& a)  { return AddElt(a); }
    110132  virtual TArray<T>&  SubElt(const TArray<T>& a);
     133  //! Operator TArray -= TArray
    111134  inline  TArray<T>&  operator -= (const TArray<T>& a)  { return SubElt(a); }
    112135// Multiplication, division element par element les deux tableaux
    … …  
    133156  void Share(const TArray<T>& a);
    134157
    135   NDataBlock<T> mNDBlock;      // Le bloc des donnees
     158  NDataBlock<T> mNDBlock; //!< Block for datas
    136159};
    137160
    138161////////////////////////////////////////////////////////////////
    139162//   Surcharge d'operateur <<
     163//! Print TArray \b a on stream \b os
    140164template <class T>
    141165inline ostream& operator << (ostream& os, const TArray<T>& a)
    … …  
    145169// Surcharge d'operateurs A (+,-,*,/) (T) x
    146170
     171//! Operator TArray = TArray + constant
    147172template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
    148173    {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
    149174
     175//! Operator TArray = constant + TArray
    150176template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
    151177    {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
    152178
     179//! Operator TArray = TArray - constant
    153180template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
    154181    {TArray<T> result(a); result.SetTemp(true); result.Sub(b); return result;}
    155182
     183//! Operator TArray = constant - TArray
    156184template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
    157185    {TArray<T> result(a); result.SetTemp(true); result.SubInv(b); return result;}
    158186
     187//! Operator TArray = TArray * constant
    159188template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
    160189    {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
    161190
     191//! Operator TArray = constant * TArray
    162192template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
    163193    {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
    164194
     195//! Operator TArray = TArray / constant
    165196template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
    166197    {TArray<T> result(a); result.SetTemp(true); result.DivInv(b); return result;}
    … …  
    169200// Surcharge d'operateurs C = A (+,-) B
    170201
     202//! Operator TArray = TArray + TArray
    171203template <class T>
    172204inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
    173205    {TArray<T> result(a); result.SetTemp(true); result.AddElt(b); return result;}
    174206
     207//! Operator TArray = TArray - TArray
    175208template <class T>
    176209inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
    … …  
    181214//        inline element acces methods
    182215// --------------------------------------------------
     216
     217//! Return element (ix,iy,iz,it,iu) value
    183218template <class T>
    184219inline T const& TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
    … …  
    189224}
    190225
     226//! Return element (ix,iy,iz,it,iu) value
    191227template <class T>
    192228inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
    … …  
    197233}
    198234
     235//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
    199236template <class T>
    200237inline T const& TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
    … …  
    204241}
    205242
     243//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
    206244template <class T>
    207245inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
    … …  
    211249}
    212250
     251//! Return element (ix,iy,iz) value
    213252template <class T>
    214253inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
    … …  
    221260}
    222261
     262//! Return element (ix,iy,iz) value
    223263template <class T>
    224264inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz)
    … …  
    231271}
    232272
     273//! Operator () : return element (ix,iy,iz,it,iu) value
    233274template <class T>
    234275inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
    … …  
    242283}
    243284
     285//! Operator () : return element (ix,iy,iz,it,iu) value
    244286template <class T>
    245287inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
    … …  
    254296
    255297
     298//! Operator [] : return element at positon ip
    256299template <class T>
    257300inline T const& TArray<T>::operator[](uint_8 ip) const
    … …  
    263306}
    264307
     308//! Operator [] : return element at positon ip
    265309template <class T>
    266310inline T & TArray<T>::operator[](uint_8 ip)
    … …  
    273317
    274318
     319//! Return the value of first element
    275320template <class T>
    276321inline T TArray<T>::toScalar()
    … …  
    281326
    282327// Typedef pour simplifier
     328//! To simplify, Array \<==\> TArray<r_8>
    283329typedef TArray<r_8> Array;
    284330
Note: See TracChangeset for help on using the changeset viewer.