Changeset 288 in Sophya for trunk/SophyaLib/NTools/tmatrix.cc


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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.