Changeset 288 in Sophya for trunk/SophyaLib/NTools


Ignore:
Timestamp:
May 3, 1999, 6:55:25 PM (26 years ago)
Author:
ansari
Message:

grosses modif avec refonte code dans tmatrix cmv 3/5/99

Location:
trunk/SophyaLib/NTools
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/NTools/matrix.cc

    r244 r288  
    1 // $Id: matrix.cc,v 1.2 1999-04-22 16:18:41 ansari Exp $
     1// $Id: matrix.cc,v 1.3 1999-05-03 16:55:21 ansari Exp $
    22
    33#include "machdefs.h"
    … …  
    1010#include "cvector.h"
    1111#include "generalfit.h"
     12#include "tmatrix.h"
    1213
    1314// Sous Linux, LN_MAXDOUBLE LN_MINDOUBLE ne semblent pas etre definies
    … …  
    4142//      Construit une matrice 1x1 (pour ppersist).
    4243//--
    43 : nr(1), nc(1), ndata(1), nalloc(1), data(new double[1])
     44: nr(1), nc(1), ndata(1), nalloc(1), data(new double[1]), FromTmatrix(false)
    4445{
    4546  // if (r<=0 || c<=0) THROW(rangeCheckErr);
    … …  
    5354//      Construit une matrice de r lignes et c colonnes.
    5455//--
    55 : nr(r), nc(c), ndata(r*c), nalloc(r*c), data(new double[r*c])
     56: nr(r), nc(c), ndata(r*c), nalloc(r*c), data(new double[r*c]), FromTmatrix(false)
    5657{
    5758  // if (r<=0 || c<=0) THROW(rangeCheckErr);
    … …  
    6667//      le tableau des valeurs : pas d'allocation.
    6768//--
    68 : nr(r), nc(c), ndata(r*c), nalloc(0), data(values)
     69: nr(r), nc(c), ndata(r*c), nalloc(0), data(values), FromTmatrix(false)
    6970{
    7071  END_CONSTRUCTOR
    … …  
    7778//--
    7879: nr(a.nr), nc(a.nc), ndata(a.nr*a.nc), nalloc(a.nr*a.nc),
    79   data(new double[a.nr*a.nc])
     80  data(new double[a.nr*a.nc]), FromTmatrix(false)
    8081{
    8182  memcpy(data, a.data, nalloc * sizeof(double));
    … …  
    8384}
    8485
     86//++
     87Matrix::Matrix(const TMatrix<r_8>& a)
     88//
     89//      Constructeur par copie a partir d'une TMatrix<r_8>.
     90//      Attention, les donnees sont partagees.
     91//--
     92: nr(a.NRows()), nc(a.NCols()), ndata(a.NRows()*a.NCols())
     93, nalloc(a.NRows()*a.NCols())
     94, data(const_cast<r_8 *>(a.Data()))
     95, FromTmatrix(true)
     96{
     97  END_CONSTRUCTOR
     98}
     99
    85100
    86101Matrix::~Matrix()
    87102{
    88103  DBASSERT(ndata == nr*nc);
    89   if (nalloc) delete[] data;
     104  if (nalloc && !FromTmatrix) delete[] data;
    90105}
    91106
    … …  
    102117{
    103118  DBASSERT(ndata == nr*nc);
    104   for (int i=0; i<ndata; i++)
    105     data[i] = 0;
     119  for (int i=0; i<ndata; i++) data[i] = 0;
    106120}
    107121

  • trunk/SophyaLib/NTools/matrix.h

    r220 r288  
    1212
    1313class GeneralFit;
     14#include "tmatrix.h"
     15//cmv template <class T> class TMatrix;
    1416
    1517// <summary> Operations matricielles </summary>
    … …  
    1820  friend class Vector;
    1921  friend class MatrixRC;
     22  friend class TMatrix<r_8>;
    2023public:
    2124  Matrix();
    … …  
    2629  // Constructeur par copie
    2730  Matrix(const Matrix& a);
     31  // Constructeur par copie a partir d'une TMatrix<r_8>
     32  Matrix(const TMatrix<r_8>& a);
    2833  // Destructeur
    2934  virtual ~Matrix();
    … …  
    151156  int nalloc;
    152157  r_8* data;
     158  bool FromTmatrix;
    153159};
    154160

  • trunk/SophyaLib/NTools/tmatrix.cc

    r286 r288  
    1 // $Id: tmatrix.cc,v 1.2 1999-04-30 11:02:52 ansari Exp $
     1// $Id: tmatrix.cc,v 1.3 1999-05-03 16:55:22 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    1313
    1414////////////////////////////////////////////////////////////////
    15 //************ Createur, Destructeur, gestion des donnees
     15//**** Createur, Destructeur
    1616
    1717template <class T>
    … …  
    3939template <class T>
    4040TMatrix<T>::TMatrix(const TMatrix<T>& a)
    41 // Constructeur par copie (partage des donnees).
     41// Constructeur par copie (partage si "a" temporaire).
    4242: mNr(a.mNr), mNc(a.mNc), mNDBlock(a.mNDBlock)
    4343{
    … …  
    4646template <class T>
    4747TMatrix<T>::TMatrix(const TMatrix<T>& a,bool share)
    48 // Constructeur par copie.
     48// Constructeur par copie avec possibilite de forcer le partage ou non.
    4949: mNr(a.mNr), mNc(a.mNc), mNDBlock(a.mNDBlock,share)
    5050{
    … …  
    5858
    5959////////////////////////////////////////////////////////////////
    60 template <class T>
    61 void TMatrix<T>::Clone(const TMatrix<T>& a)
    62 // Clone (copie de donnees) a partir de "a"
    63 // Partage des donnees si "a" est temporaire.
    64 {
    65 mNDBlock.Clone(a.mNDBlock); mNr = a.mNr; mNc = a.mNc;
    66 }
    67 
    68 template <class T>
    69 void TMatrix<T>::Reset(T v)
    70 // Reset de la matrice a "v"
    71 {
    72 mNDBlock.Reset(v);
    73 }
    74 
    75 template <class T>
    76 void TMatrix<T>::Realloc(uint_4 r,uint_4 c,bool force_alloc)
    77 // Reallocation de place
    78 {
    79 if(r==0 || c==0) throw(SzMismatchError("TMatrix::ReSize r ou c==0\n"));
    80 if(!force_alloc && mNr==r && mNc==c)  return;
    81 mNr = r; mNc = c; mNDBlock.ReSize(r*c,force_alloc);
    82 }
    83 
    84 ////////////////////////////////////////////////////////////////
    85 //**** Surcharge de TMatrix=TMatrix; TMatrix=<T> b;
    86 
    87 template <class T>
    88 TMatrix<T>& TMatrix<T>::operator = (T x)
    89 // Operateur d'affectation depuis scalaire : identite * scalaire.
    90 {
    91 if(mNr!=mNc || mNr==0)
    92   throw(SzMismatchError("TMatrix::operator= mNc!=mNr ou ==0\n"));
    93 for(uint_4 r=0;r<mNr;r++) for(uint_4 c=0;c<mNc;c++)
    94                                (*this)(r,c) = (r==c)? x: 0;
    95 return *this;
    96 }
    97 
    98 template <class T>
    99 TMatrix<T>& TMatrix<T>::operator = (const TMatrix<T>& a)
    100 // Operateur d'affectation A=a
    101 // (Re)allocation de la place memoire
    102 // sauf si "a" est cree temporairement (partage)
    103 {
    104 if(this == &a) return *this;
    105 Clone(a);
    106 return *this;
     60// Operations matricielles
     61template <class T>
     62TMatrix<T> TMatrix<T>::Transpose(void) const
     63// Transposition
     64{
     65TMatrix<T> a; a.Clone(*this); a.SetTemp(true);
     66a.mNr = mNc; a.mNc = mNr;
     67{for(int i=0; i<mNr; i++)
     68  for(int j=0; j<mNc; j++) {
     69    a(j,i) = (*this)(i,j);
     70}}
     71return a;
    10772}
    10873
    … …  
    11580// Impression de la sous-matrice (i:i+ni-1,i:j+nj-1)
    11681{
    117   os<<"TMatrix::Print("<<mNr<<","<<mNc<<")"<<endl;
     82os<<"TMatrix::Print("<<mNr<<","<<mNc<<")"<<endl;
    11883if(lp>0)
    11984  {os<<"       this="<<this<<endl; mNDBlock.Print(0,0);}
    … …  
    12994
    13095////////////////////////////////////////////////////////////////
    131 //**** Surcharge de +=,-=,*=,/= (INPLACE): TMatrix += <T> b;
    132 
    133 template <class T>
    134 TMatrix<T>& TMatrix<T>::operator += (T b)
    135 {
    136 mNDBlock += b;
    137 return *this;
    138 }
    139 
    140 template <class T>
    141 TMatrix<T>& TMatrix<T>::operator -= (T b)
    142 {
    143 mNDBlock -= b;
    144 return *this;
    145 }
    146 
    147 template <class T>
    148 TMatrix<T>& TMatrix<T>::operator *= (T b)
    149 {
    150 mNDBlock *= b;
    151 return *this;
    152 }
    153 
    154 template <class T>
    155 TMatrix<T>& TMatrix<T>::operator /= (T b)
    156 {
    157 mNDBlock /= b;
    158 return *this;
    159 }
    160 
    161 ////////////////////////////////////////////////////////////////
    162 //**** Surcharge de +=,-=,*= (INPLACE): TMatrix += TMatrix;
    163 
    164 template <class T>
    165 TMatrix<T>& TMatrix<T>::operator += (const TMatrix<T>& a)
    166 {
    167 if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
    168   throw(SzMismatchError("TMatrix::operator+=A size mismatch"));
    169 mNDBlock += a.mNDBlock;
    170 return *this;
    171 }
    172 
    173 template <class T>
    174 TMatrix<T>& TMatrix<T>::operator -= (const TMatrix<T>& a)
    175 {
    176 if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
    177   throw(SzMismatchError("TMatrix::operator-=A size mismatch"));
    178 mNDBlock -= a.mNDBlock;
    179 return *this;
    180 }
     96//**** Surcharge de *= (INPLACE): TMatrix *= TMatrix;
    18197
    18298template <class T>
    … …  
    209125
    210126////////////////////////////////////////////////////////////////
    211 //**** Surcharge de +,-,*: TMatrix = TMatrix + TMatrix;
    212 
    213 template <class T>
    214 TMatrix<T> TMatrix<T>::Add(const TMatrix<T>& b) const
    215 // C = A(this)+B
     127//**** Pour surcharge d'operateurs C = A (+,-,*,/) B
     128
     129template <class T> TMatrix<T> TMatrix<T>::Add(const TMatrix<T>& b) const
    216130{
    217131if(mNr!=b.mNr || mNc!=b.mNc)
    218   throw(SzMismatchError("NDataBlock operator C=A+B size mismatch\n"));
    219 TMatrix<T> result; result.SetTemp(true);
    220 if(b.IsTemp()) {
    221   result.Clone(b);
    222   result += *this;
    223 } else {
    224   result.Clone(*this);
    225   result += b;
    226 }
     132    throw(SzMismatchError("NDataBlock operator C=A+B size mismatch\n"));
     133TMatrix<T> result; result.SetTemp(true); result.mNr=mNr; result.mNc=mNc;
     134result.mNDBlock = mNDBlock+b.mNDBlock;
    227135return result;
    228136}
    229137
    230 template <class T>
    231 TMatrix<T> TMatrix<T>::Sub(const TMatrix<T>& b) const
    232 // C = A(this)-B
     138template <class T> TMatrix<T> TMatrix<T>::Sub(const TMatrix<T>& b) const
    233139{
    234140if(mNr!=b.mNr || mNc!=b.mNc)
    235   throw(SzMismatchError("NDataBlock operator C=A-B size mismatch\n"));
    236 TMatrix<T> result; result.SetTemp(true);
    237 if(b.IsTemp()) {
    238   result.Clone(b);
    239   result.mNDBlock = (*this).mNDBlock - result.mNDBlock;
    240 } else {
    241   result.Clone(*this);
    242   result -= b;
    243 }
     141    throw(SzMismatchError("NDataBlock operator C=A-B size mismatch\n"));
     142TMatrix<T> result; result.SetTemp(true); result.mNr=mNr; result.mNc=mNc;
     143result.mNDBlock = mNDBlock-b.mNDBlock;
    244144return result;
    245145}
    246146
    247 template <class T>
    248 TMatrix<T> TMatrix<T>::Mul(const TMatrix<T>& b) const
     147template <class T> TMatrix<T> TMatrix<T>::Mul(const TMatrix<T>& b) const
    249148// C = A(this)*B : Cij = Aik Bkj (allocation forcee dans tous les cas)
    250149{
    251150if(mNr==0 || mNc==0 || b.mNc==0 || mNc!=b.mNr)
    252151  throw(SzMismatchError("NDataBlock operator C=A*B size mismatch\n"));
    253 TMatrix<T> r; r.SetTemp(true); r.Realloc(mNr,b.mNc,true);
     152TMatrix<T> r; r.SetTemp(true); r.ReSize(mNr,b.mNc);
    254153T *ai,*aik,*bj,*bkj,*ri,*rij;
    255154for(ri=const_cast<T *>(r.Data()),ai=const_cast<T *>(Data());
    … …  
    317216is.Get(itab,2);
    318217if (dobj == NULL) dobj = new TMatrix<T>(itab[0],itab[1]);
    319 else dobj->Realloc(itab[0],itab[1],false);
     218else dobj->ReSize(itab[0],itab[1]);
    320219// On lit le NDataBlock
    321220//cmv   encore des problemes avec les consteries
    … …  
    331230uint_4 itab[2];
    332231itab[0] = dobj->NRows();
    333 itab[1] = dobj->NCol();
     232itab[1] = dobj->NCols();
    334233os.Put(itab,2);
    335234// On ecrit le NDataBlock

  • trunk/SophyaLib/NTools/tmatrix.h

    r286 r288  
    1616class TMatrix : public AnyDataObj {
    1717public:
     18
    1819  // Creation / destruction
    1920  TMatrix();
    … …  
    2627  // Temporaire?
    2728  inline bool IsTemp(void) const {return mNDBlock.IsTemp();}
    28   inline void SetTemp(bool temp=false) const
    29                      {mNDBlock.SetTemp(temp);}
     29  inline void SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
    3030
    3131  // Gestion taille/Remplissage
    32   void Clone(const TMatrix<T>& a);
    33   void Reset(T v=0);
    34   void Realloc(uint_4 r,uint_4 c,bool force_alloc=true);
     32  inline void Clone(const TMatrix<T>& a)  // Clone: copie des donnees de "a"
     33              {mNDBlock.Clone(a.mNDBlock); mNr = a.mNr; mNc = a.mNc;}
     34  inline void Reset(T v=0) {mNDBlock.Reset(v);}
     35  inline void ReSize(uint_4 r,uint_4 c)  // Reallocation de place
     36       {if(r==0||c==0) throw(SzMismatchError("TMatrix::ReSize r ou c==0\n"));
     37        mNr = r; mNc = c; mNDBlock.ReSize(r*c);}
    3538
    3639  // Informations pointeur/data
    3740  inline int NRows() const {return mNr;}
    38   inline int NCol()  const {return mNc;}
    39   T const& operator()(uint_4 r,uint_4 c) const
    40                      {return *(mNDBlock.Begin()+r*mNc+c);}
    41   T&       operator()(uint_4 r,uint_4 c)
    42                      {return *(mNDBlock.Begin()+r*mNc+c);}
     41  inline int NCols() const {return mNc;}
     42  inline T const& operator()(uint_4 r,uint_4 c) const
     43                            {return *(mNDBlock.Begin()+r*mNc+c);}
     44  inline T&       operator()(uint_4 r,uint_4 c)
     45                            {return *(mNDBlock.Begin()+r*mNc+c);}
     46  inline T const& operator[](uint_4 ip) const
     47                            {return *(mNDBlock.Begin()+ip);}
     48  inline T&       operator[](uint_4 ip)
     49                            {return *(mNDBlock.Begin()+ip);}
    4350  inline       T* Data()       {return mNDBlock.Begin();}
    4451  inline const T* Data() const {return mNDBlock.Begin();}
    … …  
    4653  inline const NDataBlock<T>& DataBlock() const {return mNDBlock;}
    4754
     55  // Operations matricielles
     56  TMatrix<T> Transpose(void) const;
     57
    4858  // Operateur d'affectation
    49   TMatrix<T>& operator = (T x);
    50   TMatrix<T>& operator = (const TMatrix<T>& a);
     59  // A = x (matrice diagonale x*Identite)
     60  inline TMatrix<T>& operator = (T x)
     61    {if(mNr!=mNc || mNr==0) throw(SzMismatchError("TMatrix::operator= mNc!=mNr ou ==0\n"));
     62     for(uint_4 r=0;r<mNr;r++) for(uint_4 c=0;c<mNc;c++) (*this)(r,c)=(r==c)?x:0;
     63     return *this;}
     64  // A = B : partage les donnees si "a" est temporaire, clone sinon.
     65  inline TMatrix<T>& operator = (const TMatrix<T>& a)
     66                {if(this == &a) return *this; CloneOrShare(a); return *this;}
    5167
    5268  // Impression
    … …  
    5571              {Print(cout,lp,i0,ni,j0,nj);}
    5672
    57   // Surcharge d'operateurs INPLACE
    58   TMatrix<T>& operator += (T b);
    59   TMatrix<T>& operator -= (T b);
    60   TMatrix<T>& operator *= (T b);
    61   TMatrix<T>& operator /= (T b);
     73  // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) (T) x
     74  inline TMatrix<T>& operator += (T b) {mNDBlock += b; return *this;}
     75  inline TMatrix<T>& operator -= (T b) {mNDBlock -= b; return *this;}
     76  inline TMatrix<T>& operator *= (T b) {mNDBlock *= b; return *this;}
     77  inline TMatrix<T>& operator /= (T b) {mNDBlock /= b; return *this;}
    6278
    63   TMatrix<T>& operator += (const TMatrix<T>& a);
    64   TMatrix<T>& operator -= (const TMatrix<T>& a);
     79  // Surcharge d'operateurs INPLACE: A (+=,-=,*=,/=) B
     80  inline TMatrix<T>& operator += (const TMatrix<T>& a)
     81              {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
     82                  throw(SzMismatchError("TMatrix::operator+=A size mismatch"));
     83               mNDBlock += a.mNDBlock; return *this;}
     84  inline TMatrix<T>& operator -= (const TMatrix<T>& a)
     85              {if(mNr==0 || mNc==0 || mNr!=a.mNr || mNc!=a.mNc)
     86                  throw(SzMismatchError("TMatrix::operator-=A size mismatch"));
     87               mNDBlock -= a.mNDBlock; return *this;}
    6588  TMatrix<T>& operator *= (const TMatrix<T>& a);
    6689
    67   // Pour surcharge d'operateurs
     90  // Pour surcharge d'operateurs C = A (+,-,*) B
    6891  TMatrix<T> Add(const TMatrix<T>& b) const;
    6992  TMatrix<T> Sub(const TMatrix<T>& b) const;
    … …  
    7194
    7295protected:
     96  // partage les donnees si "a" temporaire, clone sinon.
     97  inline void CloneOrShare(const TMatrix<T>& a)
     98              {mNDBlock.CloneOrShare(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
     99  // Share: partage les donnees de "a"
     100  inline void Share(const TMatrix<T>& a)
     101              {mNDBlock.Share(a.mNDBlock); mNr=a.mNr; mNc=a.mNc;}
     102
    73103  uint_4 mNr,mNc;
    74104  NDataBlock<T> mNDBlock;
    75105};
    76106
    77 /////////////////////////////////////////////////////////////////////////
    78 template<class T>
     107////////////////////////////////////////////////////////////////
     108// Impression
     109
     110template <class T>
    79111inline ostream& operator << (ostream& os, const TMatrix<T>& a)
    80                       {a.Print(os); return(os);}
     112                            {a.Print(os); return(os);}
    81113
    82 /////////////////////////////////////////////////////////////////////////
    83 template<class T>
    84 inline TMatrix<T> operator + (const TMatrix<T>& a, double b) {
    85   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    86   result += b;
    87   return result;
    88 }
     114////////////////////////////////////////////////////////////////
     115// Surcharge d'operateurs A (+=,-=,*=,/=) (T) x
    89116
    90 template<class T>
    91 inline TMatrix<T> operator + (double b,const TMatrix<T>& a) {
    92   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    93   result += b;
    94   return result;
    95 }
     117template <class T> inline TMatrix<T> operator + (const TMatrix<T>& a, T b)
     118    {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
    96119
    97 template<class T>
    98 inline TMatrix<T> operator - (const TMatrix<T>& a, double b) {
    99   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    100   result -= b;
    101   return result;
    102 }
     120template <class T> inline TMatrix<T> operator + (T b,const TMatrix<T>& a)
     121    {TMatrix<T> result(a); result.SetTemp(true); result += b; return result;}
    103122
    104 template<class T>
    105 inline TMatrix<T> operator - (double b,const TMatrix<T>& a) {
    106   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    107   result.DataBlock() = b - result.DataBlock();
    108   return result;
    109 }
     123template <class T> inline TMatrix<T> operator - (const TMatrix<T>& a, T b)
     124    {TMatrix<T> result(a); result.SetTemp(true); result -= b; return result;}
    110125
    111 template<class T>
    112 inline TMatrix<T> operator * (const TMatrix<T>& a, double b) {
    113   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    114   result *= b;
    115   return result;
    116 }
     126template <class T> inline TMatrix<T> operator - (T b,const TMatrix<T>& a)
     127    {TMatrix<T> result(a); result.SetTemp(true);
     128     result.DataBlock() = b-result.DataBlock(); return result;}
    117129
    118 template<class T>
    119 inline TMatrix<T> operator * (double b,const TMatrix<T>& a) {
    120   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    121   result *= b;
    122   return result;
    123 }
     130template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, T b)
     131    {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
    124132
    125 template<class T>
    126 inline TMatrix<T> operator / (const TMatrix<T>& a, double b) {
    127   TMatrix<T> result(a,false); result.DataBlock().SetTemp(true);
    128   result /= b;
    129   return result;
    130 }
     133template <class T> inline TMatrix<T> operator * (T b,const TMatrix<T>& a)
     134    {TMatrix<T> result(a); result.SetTemp(true); result *= b; return result;}
    131135
    132 /////////////////////////////////////////////////////////////////////////
    133 template<class T>
     136template <class T> inline TMatrix<T> operator / (const TMatrix<T>& a, T b)
     137    {TMatrix<T> result(a); result.SetTemp(true); result /= b; return result;}
     138
     139////////////////////////////////////////////////////////////////
     140// Surcharge d'operateurs C = A (+,-,*,/) B
     141
     142template <class T>
    134143inline TMatrix<T> operator + (const TMatrix<T>& a,const TMatrix<T>& b)
    135                              {return a.Add(b);}
     144                  {return a.Add(b);}
    136145
    137 template<class T>
     146template <class T>
    138147inline TMatrix<T> operator - (const TMatrix<T>& a,const TMatrix<T>& b)
    139                              {return a.Sub(b);}
     148                  {return a.Sub(b);}
    140149
    141 template<class T>
     150template <class T>
    142151inline TMatrix<T> operator * (const TMatrix<T>& a,const TMatrix<T>& b)
    143                              {return a.Mul(b);}
     152                  {return a.Mul(b);}
     153
    144154
    145155/////////////////////////////////////////////////////////////////////////
    … …  
    147157template <class T>
    148158class FIO_TMatrix : public  PPersist  {
    149 
    150159public:
    151             FIO_TMatrix();
    152             FIO_TMatrix(string const & filename);
    153             FIO_TMatrix(const TMatrix<T> & obj);
    154             FIO_TMatrix(TMatrix<T> * obj);
    155   virtual   ~FIO_TMatrix();
    156 
    157   virtual   AnyDataObj* DataObj();
     160  FIO_TMatrix();
     161  FIO_TMatrix(string const & filename);
     162  FIO_TMatrix(const TMatrix<T> & obj);
     163  FIO_TMatrix(TMatrix<T> * obj);
     164  virtual ~FIO_TMatrix();
     165  virtual AnyDataObj* DataObj();
    158166  inline operator TMatrix<T>() { return(*dobj); }
    159 
    160167protected :
    161   virtual void       ReadSelf(PInPersist&);           
    162   virtual void       WriteSelf(POutPersist&) const; 
     168  virtual void ReadSelf(PInPersist&);           
     169  virtual void WriteSelf(POutPersist&) const; 
    163170  TMatrix<T> * dobj;
    164171  bool ownobj;
Note: See TracChangeset for help on using the changeset viewer.