ROOT logo
// @(#)root/matrix:$Id: TMatrixTSparse.h 27658 2009-02-28 05:34:57Z pcanal $
// Authors: Fons Rademakers, Eddy Offermann   Feb 2004

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TMatrixTSparse
#define ROOT_TMatrixTSparse

#ifndef ROOT_TMatrixTBase
#include "TMatrixTBase.h"
#endif
#ifndef ROOT_TMatrixTUtils
#include "TMatrixTUtils.h"
#endif


#ifdef CBLAS
#include <vecLib/vBLAS.h>
//#include <cblas.h>
#endif

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSparse                                                       //
//                                                                      //
// Template class of a general sparse matrix in the Harwell-Boeing      //
// format                                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixT;

template<class Element> class TMatrixTSparse : public TMatrixTBase<Element> {

protected:

   Int_t   *fRowIndex;  //[fNrowIndex] row index
   Int_t   *fColIndex;  //[fNelems]    column index
   Element *fElements;  //[fNelems]

   void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,
                 Int_t init = 0,Int_t nr_nonzeros = 0);

  // Elementary constructors
   void AMultB (const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) {
                const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,b); AMultBt(a,bt,constr); }
   void AMultB (const TMatrixTSparse<Element> &a,const TMatrixT<Element>       &b,Int_t constr=0) {
                const TMatrixTSparse<Element> bsp = b;
                const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,bsp); AMultBt(a,bt,constr); }
   void AMultB (const TMatrixT<Element>       &a,const TMatrixTSparse<Element> &b,Int_t constr=0) {
                const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,b); AMultBt(a,bt,constr); }

   void AMultBt(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
   void AMultBt(const TMatrixTSparse<Element> &a,const TMatrixT<Element>       &b,Int_t constr=0);
   void AMultBt(const TMatrixT<Element>       &a,const TMatrixTSparse<Element> &b,Int_t constr=0);

   void APlusB (const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
   void APlusB (const TMatrixTSparse<Element> &a,const TMatrixT<Element>       &b,Int_t constr=0);
   void APlusB (const TMatrixT<Element>       &a,const TMatrixTSparse<Element> &b,Int_t constr=0) { APlusB(b,a,constr); }

   void AMinusB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
   void AMinusB(const TMatrixTSparse<Element> &a,const TMatrixT<Element>       &b,Int_t constr=0);
   void AMinusB(const TMatrixT<Element>       &a,const TMatrixTSparse<Element> &b,Int_t constr=0);

public:

   enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kAtA };
   enum EMatrixCreatorsOp2 { kMult,kMultTranspose,kPlus,kMinus };

   TMatrixTSparse() { fElements = 0; fRowIndex = 0; fColIndex = 0; }
   TMatrixTSparse(Int_t nrows,Int_t ncols);
   TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
   TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
                  Int_t *row, Int_t *col,Element *data);
   TMatrixTSparse(const TMatrixTSparse<Element> &another);
   TMatrixTSparse(const TMatrixT<Element>       &another);

   TMatrixTSparse(EMatrixCreatorsOp1 op,const TMatrixTSparse<Element> &prototype);
   TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSparse<Element> &b);

   virtual ~TMatrixTSparse() { Clear(); }

   virtual const Element *GetMatrixArray  () const;
   virtual       Element *GetMatrixArray  ();
   virtual const Int_t    *GetRowIndexArray() const;
   virtual       Int_t    *GetRowIndexArray();
   virtual const Int_t    *GetColIndexArray() const;
   virtual       Int_t    *GetColIndexArray();

   virtual TMatrixTBase<Element>   &SetRowIndexArray(Int_t *data) { memmove(fRowIndex,data,(this->fNrows+1)*sizeof(Int_t)); return *this; }
   virtual TMatrixTBase<Element>   &SetColIndexArray(Int_t *data) { memmove(fColIndex,data,this->fNelems*sizeof(Int_t)); return *this; }

   virtual void                     GetMatrix2Array (Element *data,Option_t *option="") const;
   virtual TMatrixTBase<Element>   &SetMatrixArray  (const Element *data,Option_t * /*option*/="")
                                                    { memcpy(fElements,data,this->fNelems*sizeof(Element)); return *this; }
   virtual TMatrixTBase<Element>   &SetMatrixArray  (Int_t nr_nonzeros,Int_t *irow,Int_t *icol,Element *data);
           TMatrixTSparse<Element> &SetSparseIndex  (Int_t nelem_new);
           TMatrixTSparse<Element> &SetSparseIndex  (const TMatrixTBase<Element> &another);
           TMatrixTSparse<Element> &SetSparseIndexAB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b);
   virtual TMatrixTBase<Element>   &InsertRow       (Int_t row,Int_t col,const Element *v,Int_t n=-1);
   virtual void                     ExtractRow      (Int_t row,Int_t col,      Element *v,Int_t n=-1) const;

   virtual TMatrixTBase<Element>   &ResizeTo(Int_t nrows,Int_t ncols,Int_t nr_nonzeros=-1);
   virtual TMatrixTBase<Element>   &ResizeTo(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros=-1);
   inline  TMatrixTBase<Element>   &ResizeTo(const TMatrixTSparse<Element> &m) {return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),
                                                                                                m.GetColUpb(),m.GetNoElements()); }

   virtual void Clear(Option_t * /*option*/ ="") { if (this->fIsOwner) {
                                                     if (fElements) delete [] fElements; fElements = 0;
                                                     if (fRowIndex) delete [] fRowIndex; fRowIndex = 0;
                                                     if (fColIndex) delete [] fColIndex; fColIndex = 0;
                                                   }
                                                   this->fNelems    = 0;
                                                   this->fNrowIndex = 0;
                                                 }

           TMatrixTSparse<Element> &Use   (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
                                           Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
   const   TMatrixTSparse<Element> &Use   (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
                                           const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
                                            { return (const TMatrixTSparse<Element>&)
                                                     ((const_cast<TMatrixTSparse<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb,nr_nonzeros,
                                                                                             const_cast<Int_t *>(pRowIndex),
                                                                                             const_cast<Int_t *>(pColIndex),
                                                                                             const_cast<Element *>(pData))); }
           TMatrixTSparse<Element> &Use   (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
                                           Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
   const   TMatrixTSparse<Element> &Use   (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
                                           const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const;
           TMatrixTSparse<Element> &Use   (TMatrixTSparse<Element> &a);
   const   TMatrixTSparse<Element> &Use   (const TMatrixTSparse<Element> &a) const;

   virtual TMatrixTBase<Element>   &GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                            TMatrixTBase<Element> &target,Option_t *option="S") const;
           TMatrixTSparse<Element>  GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
   virtual TMatrixTBase<Element>   &SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source);

   virtual Bool_t IsSymmetric() const { return (*this == TMatrixTSparse<Element>(kTransposed,*this)); }
   TMatrixTSparse<Element> &Transpose (const TMatrixTSparse<Element> &source);
   inline TMatrixTSparse<Element> &T () { return this->Transpose(*this); }

   inline void Mult(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b) { AMultB(a,b,0); }

   virtual TMatrixTBase<Element> &Zero       ();
   virtual TMatrixTBase<Element> &UnitMatrix ();

   virtual Element RowNorm () const;
   virtual Element ColNorm () const;
   virtual Int_t   NonZeros() const { return this->fNelems; }

   virtual TMatrixTBase<Element> &NormByDiag(const TVectorT<Element> &/*v*/,Option_t * /*option*/)
                                              { MayNotUse("NormByDiag"); return *this; }

   // Either access a_ij as a(i,j)
   Element  operator()(Int_t rown,Int_t coln) const;
   Element &operator()(Int_t rown,Int_t coln);

   // or as a[i][j]
   inline const TMatrixTSparseRow_const<Element> operator[](Int_t rown) const { return TMatrixTSparseRow_const<Element>(*this,rown); }
   inline       TMatrixTSparseRow      <Element> operator[](Int_t rown)       { return TMatrixTSparseRow      <Element>(*this,rown); }

   TMatrixTSparse<Element> &operator=(const TMatrixT<Element>       &source);
   TMatrixTSparse<Element> &operator=(const TMatrixTSparse<Element> &source);

   TMatrixTSparse<Element> &operator= (Element val);
   TMatrixTSparse<Element> &operator-=(Element val);
   TMatrixTSparse<Element> &operator+=(Element val);
   TMatrixTSparse<Element> &operator*=(Element val);

   TMatrixTSparse<Element> &operator+=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                if (this == &source) APlusB (tmp,tmp,1);
                                                                                else                 APlusB (tmp,source,1); return *this; }
   TMatrixTSparse<Element> &operator+=(const TMatrixT<Element>       &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                APlusB(tmp,source,1); return *this; }
   TMatrixTSparse<Element> &operator-=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                if (this == &source) AMinusB (tmp,tmp,1);
                                                                                else                 AMinusB(tmp,source,1); return *this; }
   TMatrixTSparse<Element> &operator-=(const TMatrixT<Element>       &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                AMinusB(tmp,source,1); return *this; }
   TMatrixTSparse<Element> &operator*=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                if (this == &source) AMultB (tmp,tmp,1);
                                                                                else                 AMultB (tmp,source,1); return *this; }
   TMatrixTSparse<Element> &operator*=(const TMatrixT<Element>       &source) { TMatrixTSparse<Element> tmp(*this); Clear();
                                                                                AMultB(tmp,source,1); return *this; }

   virtual TMatrixTBase  <Element> &Randomize  (Element alpha,Element beta,Double_t &seed);
   virtual TMatrixTSparse<Element> &RandomizePD(Element alpha,Element beta,Double_t &seed);

   ClassDef(TMatrixTSparse,3) // Template of Sparse Matrix class
};

template <class Element> inline const Element *TMatrixTSparse<Element>::GetMatrixArray  () const { return fElements; }
template <class Element> inline       Element *TMatrixTSparse<Element>::GetMatrixArray  ()       { return fElements; }
template <class Element> inline const Int_t   *TMatrixTSparse<Element>::GetRowIndexArray() const { return fRowIndex; }
template <class Element> inline       Int_t   *TMatrixTSparse<Element>::GetRowIndexArray()       { return fRowIndex; }
template <class Element> inline const Int_t   *TMatrixTSparse<Element>::GetColIndexArray() const { return fColIndex; }
template <class Element> inline       Int_t   *TMatrixTSparse<Element>::GetColIndexArray()       { return fColIndex; }

template <class Element>
inline       TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use   (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
                                                                      Int_t *pRowIndex,Int_t *pColIndex,Element *pData)
                                                                        { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
template <class Element>
inline const TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use   (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
                                                                      const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
                                                                        { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
template <class Element>
inline       TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use   (TMatrixTSparse<Element> &a)
                                                                        { R__ASSERT(a.IsValid());
                                                                           return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
                                                                                      a.GetNoElements(),a.GetRowIndexArray(),
                                                                                      a.GetColIndexArray(),a.GetMatrixArray()); }
template <class Element>
inline const TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use   (const TMatrixTSparse<Element> &a) const
                                                                        { R__ASSERT(a.IsValid());
                                                                           return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
                                                                                      a.GetNoElements(),a.GetRowIndexArray(),
                                                                                      a.GetColIndexArray(),a.GetMatrixArray()); }

template <class Element>
inline       TMatrixTSparse<Element>  TMatrixTSparse<Element>::GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                                                      Option_t *option) const
                                                                        {
                                                                          TMatrixTSparse<Element> tmp;
                                                                          this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
                                                                          return tmp;
                                                                        }

template <class Element> TMatrixTSparse<Element>  operator+ (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator+ (const TMatrixTSparse<Element> &source1,const TMatrixT<Element>       &source2);
template <class Element> TMatrixTSparse<Element>  operator+ (const TMatrixT<Element>       &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator+ (const TMatrixTSparse<Element> &source ,      Element                  val    );
template <class Element> TMatrixTSparse<Element>  operator+ (      Element                  val    ,const TMatrixTSparse<Element> &source );
template <class Element> TMatrixTSparse<Element>  operator- (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator- (const TMatrixTSparse<Element> &source1,const TMatrixT<Element>       &source2);
template <class Element> TMatrixTSparse<Element>  operator- (const TMatrixT<Element>       &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator- (const TMatrixTSparse<Element> &source ,      Element                  val    );
template <class Element> TMatrixTSparse<Element>  operator- (      Element                  val    ,const TMatrixTSparse<Element> &source );
template <class Element> TMatrixTSparse<Element>  operator* (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator* (const TMatrixTSparse<Element> &source1,const TMatrixT<Element>       &source2);
template <class Element> TMatrixTSparse<Element>  operator* (const TMatrixT<Element>       &source1,const TMatrixTSparse<Element> &source2);
template <class Element> TMatrixTSparse<Element>  operator* (      Element                  val    ,const TMatrixTSparse<Element> &source );
template <class Element> TMatrixTSparse<Element>  operator* (const TMatrixTSparse<Element> &source,       Element                  val    );

template <class Element> TMatrixTSparse<Element> &Add        (TMatrixTSparse<Element> &target,      Element                   scalar,
                                                              const TMatrixTSparse<Element> &source);
template <class Element> TMatrixTSparse<Element> &ElementMult(TMatrixTSparse<Element> &target,const TMatrixTSparse<Element>  &source);
template <class Element> TMatrixTSparse<Element> &ElementDiv (TMatrixTSparse<Element> &target,const TMatrixTSparse<Element>  &source);

template <class Element> Bool_t AreCompatible(const TMatrixTSparse<Element> &m1,const TMatrixTSparse<Element> &m2,Int_t verbose=0);

#endif
 TMatrixTSparse.h:1
 TMatrixTSparse.h:2
 TMatrixTSparse.h:3
 TMatrixTSparse.h:4
 TMatrixTSparse.h:5
 TMatrixTSparse.h:6
 TMatrixTSparse.h:7
 TMatrixTSparse.h:8
 TMatrixTSparse.h:9
 TMatrixTSparse.h:10
 TMatrixTSparse.h:11
 TMatrixTSparse.h:12
 TMatrixTSparse.h:13
 TMatrixTSparse.h:14
 TMatrixTSparse.h:15
 TMatrixTSparse.h:16
 TMatrixTSparse.h:17
 TMatrixTSparse.h:18
 TMatrixTSparse.h:19
 TMatrixTSparse.h:20
 TMatrixTSparse.h:21
 TMatrixTSparse.h:22
 TMatrixTSparse.h:23
 TMatrixTSparse.h:24
 TMatrixTSparse.h:25
 TMatrixTSparse.h:26
 TMatrixTSparse.h:27
 TMatrixTSparse.h:28
 TMatrixTSparse.h:29
 TMatrixTSparse.h:30
 TMatrixTSparse.h:31
 TMatrixTSparse.h:32
 TMatrixTSparse.h:33
 TMatrixTSparse.h:34
 TMatrixTSparse.h:35
 TMatrixTSparse.h:36
 TMatrixTSparse.h:37
 TMatrixTSparse.h:38
 TMatrixTSparse.h:39
 TMatrixTSparse.h:40
 TMatrixTSparse.h:41
 TMatrixTSparse.h:42
 TMatrixTSparse.h:43
 TMatrixTSparse.h:44
 TMatrixTSparse.h:45
 TMatrixTSparse.h:46
 TMatrixTSparse.h:47
 TMatrixTSparse.h:48
 TMatrixTSparse.h:49
 TMatrixTSparse.h:50
 TMatrixTSparse.h:51
 TMatrixTSparse.h:52
 TMatrixTSparse.h:53
 TMatrixTSparse.h:54
 TMatrixTSparse.h:55
 TMatrixTSparse.h:56
 TMatrixTSparse.h:57
 TMatrixTSparse.h:58
 TMatrixTSparse.h:59
 TMatrixTSparse.h:60
 TMatrixTSparse.h:61
 TMatrixTSparse.h:62
 TMatrixTSparse.h:63
 TMatrixTSparse.h:64
 TMatrixTSparse.h:65
 TMatrixTSparse.h:66
 TMatrixTSparse.h:67
 TMatrixTSparse.h:68
 TMatrixTSparse.h:69
 TMatrixTSparse.h:70
 TMatrixTSparse.h:71
 TMatrixTSparse.h:72
 TMatrixTSparse.h:73
 TMatrixTSparse.h:74
 TMatrixTSparse.h:75
 TMatrixTSparse.h:76
 TMatrixTSparse.h:77
 TMatrixTSparse.h:78
 TMatrixTSparse.h:79
 TMatrixTSparse.h:80
 TMatrixTSparse.h:81
 TMatrixTSparse.h:82
 TMatrixTSparse.h:83
 TMatrixTSparse.h:84
 TMatrixTSparse.h:85
 TMatrixTSparse.h:86
 TMatrixTSparse.h:87
 TMatrixTSparse.h:88
 TMatrixTSparse.h:89
 TMatrixTSparse.h:90
 TMatrixTSparse.h:91
 TMatrixTSparse.h:92
 TMatrixTSparse.h:93
 TMatrixTSparse.h:94
 TMatrixTSparse.h:95
 TMatrixTSparse.h:96
 TMatrixTSparse.h:97
 TMatrixTSparse.h:98
 TMatrixTSparse.h:99
 TMatrixTSparse.h:100
 TMatrixTSparse.h:101
 TMatrixTSparse.h:102
 TMatrixTSparse.h:103
 TMatrixTSparse.h:104
 TMatrixTSparse.h:105
 TMatrixTSparse.h:106
 TMatrixTSparse.h:107
 TMatrixTSparse.h:108
 TMatrixTSparse.h:109
 TMatrixTSparse.h:110
 TMatrixTSparse.h:111
 TMatrixTSparse.h:112
 TMatrixTSparse.h:113
 TMatrixTSparse.h:114
 TMatrixTSparse.h:115
 TMatrixTSparse.h:116
 TMatrixTSparse.h:117
 TMatrixTSparse.h:118
 TMatrixTSparse.h:119
 TMatrixTSparse.h:120
 TMatrixTSparse.h:121
 TMatrixTSparse.h:122
 TMatrixTSparse.h:123
 TMatrixTSparse.h:124
 TMatrixTSparse.h:125
 TMatrixTSparse.h:126
 TMatrixTSparse.h:127
 TMatrixTSparse.h:128
 TMatrixTSparse.h:129
 TMatrixTSparse.h:130
 TMatrixTSparse.h:131
 TMatrixTSparse.h:132
 TMatrixTSparse.h:133
 TMatrixTSparse.h:134
 TMatrixTSparse.h:135
 TMatrixTSparse.h:136
 TMatrixTSparse.h:137
 TMatrixTSparse.h:138
 TMatrixTSparse.h:139
 TMatrixTSparse.h:140
 TMatrixTSparse.h:141
 TMatrixTSparse.h:142
 TMatrixTSparse.h:143
 TMatrixTSparse.h:144
 TMatrixTSparse.h:145
 TMatrixTSparse.h:146
 TMatrixTSparse.h:147
 TMatrixTSparse.h:148
 TMatrixTSparse.h:149
 TMatrixTSparse.h:150
 TMatrixTSparse.h:151
 TMatrixTSparse.h:152
 TMatrixTSparse.h:153
 TMatrixTSparse.h:154
 TMatrixTSparse.h:155
 TMatrixTSparse.h:156
 TMatrixTSparse.h:157
 TMatrixTSparse.h:158
 TMatrixTSparse.h:159
 TMatrixTSparse.h:160
 TMatrixTSparse.h:161
 TMatrixTSparse.h:162
 TMatrixTSparse.h:163
 TMatrixTSparse.h:164
 TMatrixTSparse.h:165
 TMatrixTSparse.h:166
 TMatrixTSparse.h:167
 TMatrixTSparse.h:168
 TMatrixTSparse.h:169
 TMatrixTSparse.h:170
 TMatrixTSparse.h:171
 TMatrixTSparse.h:172
 TMatrixTSparse.h:173
 TMatrixTSparse.h:174
 TMatrixTSparse.h:175
 TMatrixTSparse.h:176
 TMatrixTSparse.h:177
 TMatrixTSparse.h:178
 TMatrixTSparse.h:179
 TMatrixTSparse.h:180
 TMatrixTSparse.h:181
 TMatrixTSparse.h:182
 TMatrixTSparse.h:183
 TMatrixTSparse.h:184
 TMatrixTSparse.h:185
 TMatrixTSparse.h:186
 TMatrixTSparse.h:187
 TMatrixTSparse.h:188
 TMatrixTSparse.h:189
 TMatrixTSparse.h:190
 TMatrixTSparse.h:191
 TMatrixTSparse.h:192
 TMatrixTSparse.h:193
 TMatrixTSparse.h:194
 TMatrixTSparse.h:195
 TMatrixTSparse.h:196
 TMatrixTSparse.h:197
 TMatrixTSparse.h:198
 TMatrixTSparse.h:199
 TMatrixTSparse.h:200
 TMatrixTSparse.h:201
 TMatrixTSparse.h:202
 TMatrixTSparse.h:203
 TMatrixTSparse.h:204
 TMatrixTSparse.h:205
 TMatrixTSparse.h:206
 TMatrixTSparse.h:207
 TMatrixTSparse.h:208
 TMatrixTSparse.h:209
 TMatrixTSparse.h:210
 TMatrixTSparse.h:211
 TMatrixTSparse.h:212
 TMatrixTSparse.h:213
 TMatrixTSparse.h:214
 TMatrixTSparse.h:215
 TMatrixTSparse.h:216
 TMatrixTSparse.h:217
 TMatrixTSparse.h:218
 TMatrixTSparse.h:219
 TMatrixTSparse.h:220
 TMatrixTSparse.h:221
 TMatrixTSparse.h:222
 TMatrixTSparse.h:223
 TMatrixTSparse.h:224
 TMatrixTSparse.h:225
 TMatrixTSparse.h:226
 TMatrixTSparse.h:227
 TMatrixTSparse.h:228
 TMatrixTSparse.h:229
 TMatrixTSparse.h:230
 TMatrixTSparse.h:231
 TMatrixTSparse.h:232
 TMatrixTSparse.h:233
 TMatrixTSparse.h:234
 TMatrixTSparse.h:235
 TMatrixTSparse.h:236
 TMatrixTSparse.h:237
 TMatrixTSparse.h:238
 TMatrixTSparse.h:239
 TMatrixTSparse.h:240
 TMatrixTSparse.h:241
 TMatrixTSparse.h:242
 TMatrixTSparse.h:243
 TMatrixTSparse.h:244
 TMatrixTSparse.h:245
 TMatrixTSparse.h:246
 TMatrixTSparse.h:247
 TMatrixTSparse.h:248
 TMatrixTSparse.h:249
 TMatrixTSparse.h:250
 TMatrixTSparse.h:251
 TMatrixTSparse.h:252
 TMatrixTSparse.h:253
 TMatrixTSparse.h:254
 TMatrixTSparse.h:255
 TMatrixTSparse.h:256
 TMatrixTSparse.h:257
 TMatrixTSparse.h:258