Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TMatrixTSparse.h
Go to the documentation of this file.
1 // @(#)root/matrix:$Id$
2 // Authors: Fons Rademakers, Eddy Offermann Feb 2004
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TMatrixTSparse
13 #define ROOT_TMatrixTSparse
14 
15 #include "TMatrixTBase.h"
16 #include "TMatrixTUtils.h"
17 
18 
19 #ifdef CBLAS
20 #include <vecLib/vBLAS.h>
21 //#include <cblas.h>
22 #endif
23 
24 //////////////////////////////////////////////////////////////////////////
25 // //
26 // TMatrixTSparse //
27 // //
28 // Template class of a general sparse matrix in the Harwell-Boeing //
29 // format //
30 // //
31 //////////////////////////////////////////////////////////////////////////
32 
33 template<class Element> class TMatrixT;
34 
35 template<class Element> class TMatrixTSparse : public TMatrixTBase<Element> {
36 
37 protected:
38 
39  Int_t *fRowIndex; //[fNrowIndex] row index
40  Int_t *fColIndex; //[fNelems] column index
41  Element *fElements; //[fNelems]
42 
43  void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,
44  Int_t init = 0,Int_t nr_nonzeros = 0);
45 
46  // Elementary constructors
47  void AMultB (const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) {
48  const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,b); AMultBt(a,bt,constr); }
49  void AMultB (const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0) {
50  const TMatrixTSparse<Element> bsp = b;
51  const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,bsp); AMultBt(a,bt,constr); }
52  void AMultB (const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) {
53  const TMatrixTSparse<Element> bt(TMatrixTSparse::kTransposed,b); AMultBt(a,bt,constr); }
54 
55  void AMultBt(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
56  void AMultBt(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
57  void AMultBt(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
58 
59  void APlusB (const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
60  void APlusB (const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
61  void APlusB (const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) { APlusB(b,a,constr); }
62 
63  void AMinusB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
64  void AMinusB(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
65  void AMinusB(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
66 
67 public:
68 
69  enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kAtA };
70  enum EMatrixCreatorsOp2 { kMult,kMultTranspose,kPlus,kMinus };
71 
72  TMatrixTSparse() { fElements = 0; fRowIndex = 0; fColIndex = 0; }
73  TMatrixTSparse(Int_t nrows,Int_t ncols);
74  TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
75  TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
76  Int_t *row, Int_t *col,Element *data);
77  TMatrixTSparse(const TMatrixTSparse<Element> &another);
78  TMatrixTSparse(const TMatrixT<Element> &another);
79 
80  TMatrixTSparse(EMatrixCreatorsOp1 op,const TMatrixTSparse<Element> &prototype);
81  TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSparse<Element> &b);
82  TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixT <Element> &b);
83  TMatrixTSparse(const TMatrixT <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSparse<Element> &b);
84 
85  virtual ~TMatrixTSparse() { TMatrixTSparse::Clear(); }
86 
87  virtual const Element *GetMatrixArray () const;
88  virtual Element *GetMatrixArray ();
89  virtual const Int_t *GetRowIndexArray() const;
90  virtual Int_t *GetRowIndexArray();
91  virtual const Int_t *GetColIndexArray() const;
92  virtual Int_t *GetColIndexArray();
93 
94  virtual TMatrixTBase<Element> &SetRowIndexArray(Int_t *data) { memmove(fRowIndex,data,(this->fNrows+1)*sizeof(Int_t)); return *this; }
95  virtual TMatrixTBase<Element> &SetColIndexArray(Int_t *data) { memmove(fColIndex,data,this->fNelems*sizeof(Int_t)); return *this; }
96 
97  TMatrixTSparse<Element> &SetSparseIndex (Int_t nelem_new);
98  TMatrixTSparse<Element> &SetSparseIndex (const TMatrixTBase<Element> &another);
99  TMatrixTSparse<Element> &SetSparseIndexAB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b);
100  TMatrixTSparse<Element> &SetSparseIndexAB(const TMatrixT <Element> &a,const TMatrixTSparse<Element> &b);
101  TMatrixTSparse<Element> &SetSparseIndexAB(const TMatrixTSparse<Element> &a,const TMatrixT <Element> &b)
102  { return SetSparseIndexAB(b,a); }
103 
104  virtual void GetMatrix2Array (Element *data,Option_t * /*option*/ ="") const;
105  virtual TMatrixTBase<Element> &SetMatrixArray (const Element *data,Option_t * /*option*/="")
106  { memcpy(fElements,data,this->fNelems*sizeof(Element)); return *this; }
107  virtual TMatrixTBase<Element> &SetMatrixArray (Int_t nr_nonzeros,Int_t *irow,Int_t *icol,Element *data);
108  virtual TMatrixTBase<Element> &InsertRow (Int_t row,Int_t col,const Element *v,Int_t n=-1);
109  virtual void ExtractRow (Int_t row,Int_t col, Element *v,Int_t n=-1) const;
110 
111  virtual TMatrixTBase<Element> &ResizeTo(Int_t nrows,Int_t ncols,Int_t nr_nonzeros=-1);
112  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);
113  inline TMatrixTBase<Element> &ResizeTo(const TMatrixTSparse<Element> &m) {return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),
114  m.GetColUpb(),m.GetNoElements()); }
115 
116  virtual void Clear(Option_t * /*option*/ ="") { if (this->fIsOwner) {
117  if (fElements) { delete [] fElements; fElements = 0; }
118  if (fRowIndex) { delete [] fRowIndex; fRowIndex = 0; }
119  if (fColIndex) { delete [] fColIndex; fColIndex = 0; }
120  }
121  this->fNelems = 0;
122  this->fNrowIndex = 0;
123  }
124 
125  TMatrixTSparse<Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
126  Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
127  const TMatrixTSparse<Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
128  const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
129  { return (const TMatrixTSparse<Element>&)
130  ((const_cast<TMatrixTSparse<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb,nr_nonzeros,
131  const_cast<Int_t *>(pRowIndex),
132  const_cast<Int_t *>(pColIndex),
133  const_cast<Element *>(pData))); }
134  TMatrixTSparse<Element> &Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
135  Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
136  const TMatrixTSparse<Element> &Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
137  const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const;
138  TMatrixTSparse<Element> &Use (TMatrixTSparse<Element> &a);
139  const TMatrixTSparse<Element> &Use (const TMatrixTSparse<Element> &a) const;
140 
141  virtual TMatrixTBase<Element> &GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
142  TMatrixTBase<Element> &target,Option_t *option="S") const;
143  TMatrixTSparse<Element> GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
144  virtual TMatrixTBase<Element> &SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source);
145 
146  virtual Bool_t IsSymmetric() const { return (*this == TMatrixTSparse<Element>(kTransposed,*this)); }
147  TMatrixTSparse<Element> &Transpose (const TMatrixTSparse<Element> &source);
148  inline TMatrixTSparse<Element> &T () { return this->Transpose(*this); }
149 
150  inline void Mult(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b) { AMultB(a,b,0); }
151 
152  virtual TMatrixTBase<Element> &Zero ();
153  virtual TMatrixTBase<Element> &UnitMatrix ();
154 
155  virtual Element RowNorm () const;
156  virtual Element ColNorm () const;
157  virtual Int_t NonZeros() const { return this->fNelems; }
158 
159  virtual TMatrixTBase<Element> &NormByDiag(const TVectorT<Element> &/*v*/,Option_t * /*option*/)
160  { MayNotUse("NormByDiag"); return *this; }
161 
162  // Either access a_ij as a(i,j)
163  Element operator()(Int_t rown,Int_t coln) const;
164  Element &operator()(Int_t rown,Int_t coln);
165 
166  // or as a[i][j]
167  inline const TMatrixTSparseRow_const<Element> operator[](Int_t rown) const { return TMatrixTSparseRow_const<Element>(*this,rown); }
168  inline TMatrixTSparseRow <Element> operator[](Int_t rown) { return TMatrixTSparseRow <Element>(*this,rown); }
169 
170  TMatrixTSparse<Element> &operator=(const TMatrixT<Element> &source);
171  TMatrixTSparse<Element> &operator=(const TMatrixTSparse<Element> &source);
172 
173  TMatrixTSparse<Element> &operator= (Element val);
174  TMatrixTSparse<Element> &operator-=(Element val);
175  TMatrixTSparse<Element> &operator+=(Element val);
176  TMatrixTSparse<Element> &operator*=(Element val);
177 
178  TMatrixTSparse<Element> &operator+=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
179  if (this == &source) APlusB (tmp,tmp,1);
180  else APlusB (tmp,source,1);
181  return *this; }
182  TMatrixTSparse<Element> &operator+=(const TMatrixT<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
183  APlusB(tmp,source,1); return *this; }
184  TMatrixTSparse<Element> &operator-=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
185  if (this == &source) AMinusB (tmp,tmp,1);
186  else AMinusB(tmp,source,1);
187  return *this; }
188  TMatrixTSparse<Element> &operator-=(const TMatrixT<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
189  AMinusB(tmp,source,1); return *this; }
190  TMatrixTSparse<Element> &operator*=(const TMatrixTSparse<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
191  if (this == &source) AMultB (tmp,tmp,1);
192  else AMultB (tmp,source,1);
193  return *this; }
194  TMatrixTSparse<Element> &operator*=(const TMatrixT<Element> &source) { TMatrixTSparse<Element> tmp(*this); Clear();
195  AMultB(tmp,source,1);
196  return *this; }
197 
198  virtual TMatrixTBase <Element> &Randomize (Element alpha,Element beta,Double_t &seed);
199  virtual TMatrixTSparse<Element> &RandomizePD(Element alpha,Element beta,Double_t &seed);
200 
201  ClassDef(TMatrixTSparse,3) // Template of Sparse Matrix class
202 };
203 
204 #ifndef __CINT__
205 // When building with -fmodules, it instantiates all pending instantiations,
206 // instead of delaying them until the end of the translation unit.
207 // We 'got away with' probably because the use and the definition of the
208 // explicit specialization do not occur in the same TU.
209 //
210 // In case we are building with -fmodules, we need to forward declare the
211 // specialization in order to compile the dictionary G__Matrix.cxx.
212 template <> TClass *TMatrixTSparse<double>::Class();
213 #endif // __CINT__
214 
215 template <class Element> inline const Element *TMatrixTSparse<Element>::GetMatrixArray () const { return fElements; }
216 template <class Element> inline Element *TMatrixTSparse<Element>::GetMatrixArray () { return fElements; }
217 template <class Element> inline const Int_t *TMatrixTSparse<Element>::GetRowIndexArray() const { return fRowIndex; }
218 template <class Element> inline Int_t *TMatrixTSparse<Element>::GetRowIndexArray() { return fRowIndex; }
219 template <class Element> inline const Int_t *TMatrixTSparse<Element>::GetColIndexArray() const { return fColIndex; }
220 template <class Element> inline Int_t *TMatrixTSparse<Element>::GetColIndexArray() { return fColIndex; }
221 
222 template <class Element>
223 inline TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
224  Int_t *pRowIndex,Int_t *pColIndex,Element *pData)
225  { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
226 template <class Element>
227 inline const TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
228  const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
229  { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
230 template <class Element>
231 inline TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use (TMatrixTSparse<Element> &a)
232  { R__ASSERT(a.IsValid());
233  return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
234  a.GetNoElements(),a.GetRowIndexArray(),
235  a.GetColIndexArray(),a.GetMatrixArray()); }
236 template <class Element>
237 inline const TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use (const TMatrixTSparse<Element> &a) const
238  { R__ASSERT(a.IsValid());
239  return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
240  a.GetNoElements(),a.GetRowIndexArray(),
241  a.GetColIndexArray(),a.GetMatrixArray()); }
242 
243 template <class Element>
244 inline TMatrixTSparse<Element> TMatrixTSparse<Element>::GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
245  Option_t *option) const
246  {
247  TMatrixTSparse<Element> tmp;
248  this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
249  return tmp;
250  }
251 
252 template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
253 template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
254 template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
255 template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source , Element val );
256 template <class Element> TMatrixTSparse<Element> operator+ ( Element val ,const TMatrixTSparse<Element> &source );
257 template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
258 template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
259 template <class Element> TMatrixTSparse<Element> operator- (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
260 template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source , Element val );
261 template <class Element> TMatrixTSparse<Element> operator- ( Element val ,const TMatrixTSparse<Element> &source );
262 template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
263 template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
264 template <class Element> TMatrixTSparse<Element> operator* (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
265 template <class Element> TMatrixTSparse<Element> operator* ( Element val ,const TMatrixTSparse<Element> &source );
266 template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source, Element val );
267 
268 template <class Element> TMatrixTSparse<Element> &Add (TMatrixTSparse<Element> &target, Element scalar,
269  const TMatrixTSparse<Element> &source);
270 template <class Element> TMatrixTSparse<Element> &ElementMult(TMatrixTSparse<Element> &target,const TMatrixTSparse<Element> &source);
271 template <class Element> TMatrixTSparse<Element> &ElementDiv (TMatrixTSparse<Element> &target,const TMatrixTSparse<Element> &source);
272 
273 template <class Element> Bool_t AreCompatible(const TMatrixTSparse<Element> &m1,const TMatrixTSparse<Element> &m2,Int_t verbose=0);
274 
275 #endif