ROOT  6.06/09
Reference Guide
TMatrixTUtils.h
Go to the documentation of this file.
1 // @(#)root/matrix:$Id$
2 // Authors: Fons Rademakers, Eddy Offermann Nov 2003
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_TMatrixTUtils
13 #define ROOT_TMatrixTUtils
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // Matrix utility classes. //
18 // //
19 // Templates of utility classes in the Linear Algebra Package. //
20 // The following classes are defined here: //
21 // //
22 // Different matrix views without copying data elements : //
23 // TMatrixTRow_const TMatrixTRow //
24 // TMatrixTColumn_const TMatrixTColumn //
25 // TMatrixTDiag_const TMatrixTDiag //
26 // TMatrixTFlat_const TMatrixTFlat //
27 // TMatrixTSub_const TMatrixTSub //
28 // TMatrixTSparseRow_const TMatrixTSparseRow //
29 // TMatrixTSparseDiag_const TMatrixTSparseDiag //
30 // //
31 // TElementActionT //
32 // TElementPosActionT //
33 // //
34 //////////////////////////////////////////////////////////////////////////
35 
36 #ifndef ROOT_TMatrixTBase
37 #include "TMatrixTBase.h"
38 #endif
39 
40 template<class Element> class TVectorT;
41 template<class Element> class TMatrixT;
42 template<class Element> class TMatrixTSym;
43 template<class Element> class TMatrixTSparse;
44 
45 //////////////////////////////////////////////////////////////////////////
46 // //
47 // TElementActionT //
48 // //
49 // A class to do a specific operation on every vector or matrix element //
50 // (regardless of it position) as the object is being traversed. //
51 // This is an abstract class. Derived classes need to implement the //
52 // action function Operation(). //
53 // //
54 //////////////////////////////////////////////////////////////////////////
55 
56 template<class Element> class TElementActionT {
57 
58 #ifndef __CINT__
59 friend class TMatrixTBase <Element>;
60 friend class TMatrixT <Element>;
61 friend class TMatrixTSym <Element>;
62 friend class TMatrixTSparse<Element>;
63 friend class TVectorT <Element>;
64 #endif
65 
66 protected:
67  virtual ~TElementActionT() { }
68  virtual void Operation(Element &element) const = 0;
69 
70 private:
71  TElementActionT& operator=(const TElementActionT<Element> &) {return *this;}
72 };
73 
74 //////////////////////////////////////////////////////////////////////////
75 // //
76 // TElementPosActionT //
77 // //
78 // A class to do a specific operation on every vector or matrix element //
79 // as the object is being traversed. This is an abstract class. //
80 // Derived classes need to implement the action function Operation(). //
81 // In the action function the location of the current element is //
82 // known (fI=row, fJ=columns). //
83 // //
84 //////////////////////////////////////////////////////////////////////////
85 
86 template<class Element> class TElementPosActionT {
87 
88 #ifndef __CINT__
89 friend class TMatrixTBase <Element>;
90 friend class TMatrixT <Element>;
91 friend class TMatrixTSym <Element>;
92 friend class TMatrixTSparse<Element>;
93 friend class TVectorT <Element>;
94 #endif
95 
96 protected:
97  mutable Int_t fI; // i position of element being passed to Operation()
98  mutable Int_t fJ; // j position of element being passed to Operation()
99  virtual ~TElementPosActionT() { }
100  virtual void Operation(Element &element) const = 0;
101 
102 private:
103  TElementPosActionT<Element>& operator=(const TElementPosActionT<Element> &) {return *this;}
104 };
105 
106 //////////////////////////////////////////////////////////////////////////
107 // //
108 // TMatrixTRow_const //
109 // //
110 // Template class represents a row of a TMatrixT/TMatrixTSym //
111 // //
112 //////////////////////////////////////////////////////////////////////////
113 
114 template<class Element> class TMatrixTRow_const {
115 
116 protected:
117  const TMatrixTBase<Element> *fMatrix; // the matrix I am a row of
118  Int_t fRowInd; // effective row index
119  Int_t fInc; // if ptr = @a[row,i], then ptr+inc = @a[row,i+1]
120  const Element *fPtr; // pointer to the a[row,0]
121 
122 public:
123  TMatrixTRow_const() { fMatrix = 0; fRowInd = 0; fInc = 0; fPtr = 0; }
124  TMatrixTRow_const(const TMatrixT <Element> &matrix,Int_t row);
125  TMatrixTRow_const(const TMatrixTSym<Element> &matrix,Int_t row);
126  TMatrixTRow_const(const TMatrixTRow_const<Element>& trc):
127  fMatrix(trc.fMatrix), fRowInd(trc.fRowInd), fInc(trc.fInc), fPtr(trc.fPtr) { }
128  TMatrixTRow_const<Element>& operator=(const TMatrixTRow_const<Element>& trc) {
129  if(this != &trc) { fMatrix=trc.fMatrix; fRowInd=trc.fRowInd; fInc=trc.fInc; fPtr=trc.fPtr; } return *this;}
130  virtual ~TMatrixTRow_const() { }
131 
132  inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
133  inline Int_t GetRowIndex() const { return fRowInd; }
134  inline Int_t GetInc () const { return fInc; }
135  inline const Element *GetPtr () const { return fPtr; }
136  inline const Element &operator ()(Int_t i) const {
137  if (!fMatrix) return TMatrixTBase<Element>::NaNValue();
138  R__ASSERT(fMatrix->IsValid());
139  const Int_t acoln = i-fMatrix->GetColLwb();
140  if (acoln < fMatrix->GetNcols() && acoln >= 0)
141  return fPtr[acoln];
142  else {
143  Error("operator()","Request col(%d) outside matrix range of %d - %d",
144  i,fMatrix->GetColLwb(),fMatrix->GetColLwb()+fMatrix->GetNcols());
145  return TMatrixTBase<Element>::NaNValue();
146  }
147  }
148  inline const Element &operator [](Int_t i) const { return (*(const TMatrixTRow_const<Element> *)this)(i); }
149 
150  ClassDef(TMatrixTRow_const,0) // Template of General Matrix Row Access class
151 };
152 
153 template<class Element> class TMatrixTRow : public TMatrixTRow_const<Element> {
154 
155 public:
156  TMatrixTRow() {}
157  TMatrixTRow(TMatrixT <Element> &matrix,Int_t row);
158  TMatrixTRow(TMatrixTSym<Element> &matrix,Int_t row);
159  TMatrixTRow(const TMatrixTRow<Element> &mr);
160 
161  inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
162 
163  inline const Element &operator()(Int_t i) const {
164  if (!this->fMatrix) return TMatrixTBase<Element>::NaNValue();
165  R__ASSERT(this->fMatrix->IsValid());
166  const Int_t acoln = i-this->fMatrix->GetColLwb();
167  if (acoln < this->fMatrix->GetNcols() || acoln >= 0)
168  return (this->fPtr)[acoln];
169  else {
170  Error("operator()","Request col(%d) outside matrix range of %d - %d",
171  i,this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
172  return TMatrixTBase<Element>::NaNValue();
173  }
174  }
175  inline Element &operator()(Int_t i) {
176  if (!this->fMatrix) return TMatrixTBase<Element>::NaNValue();
177  R__ASSERT(this->fMatrix->IsValid());
178  const Int_t acoln = i-this->fMatrix->GetColLwb();
179  if (acoln < this->fMatrix->GetNcols() && acoln >= 0)
180  return (const_cast<Element *>(this->fPtr))[acoln];
181  else {
182  Error("operator()","Request col(%d) outside matrix range of %d - %d",
183  i,this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
184  //return (const_cast<Element *>(this->fPtr))[0];
185  return TMatrixTBase<Element>::NaNValue();
186  }
187  }
188  inline const Element &operator[](Int_t i) const { return (*(const TMatrixTRow<Element> *)this)(i); }
189  inline Element &operator[](Int_t i) { return (*( TMatrixTRow<Element> *)this)(i); }
190 
191  void operator= (Element val);
192  void operator+=(Element val);
193  void operator*=(Element val);
194 
195  void operator=(const TMatrixTRow_const<Element> &r);
196  TMatrixTRow<Element>& operator=(const TMatrixTRow <Element> &r) { operator=((TMatrixTRow_const<Element> &)r); return *this;}
197  void operator=(const TVectorT <Element> &vec);
198 
199  void operator+=(const TMatrixTRow_const<Element> &r);
200  void operator*=(const TMatrixTRow_const<Element> &r);
201 
202  ClassDef(TMatrixTRow,0) // Template of General Matrix Row Access class
203 };
204 
205 //////////////////////////////////////////////////////////////////////////
206 // //
207 // TMatrixTColumn_const //
208 // //
209 // Template class represents a column of a TMatrixT/TMatrixTSym //
210 // //
211 //////////////////////////////////////////////////////////////////////////
212 
213 template<class Element> class TMatrixTColumn_const {
214 
215 protected:
216  const TMatrixTBase<Element> *fMatrix; // the matrix I am a column of
217  Int_t fColInd; // effective column index
218  Int_t fInc; // if ptr = @a[i,col], then ptr+inc = @a[i+1,col]
219  const Element *fPtr; // pointer to the a[0,col] column
220 
221 public:
222  TMatrixTColumn_const() { fMatrix = 0; fColInd = 0; fInc = 0; fPtr = 0; }
223  TMatrixTColumn_const(const TMatrixT <Element> &matrix,Int_t col);
224  TMatrixTColumn_const(const TMatrixTSym<Element> &matrix,Int_t col);
225  TMatrixTColumn_const(const TMatrixTColumn_const<Element>& trc):
226  fMatrix(trc.fMatrix), fColInd(trc.fColInd), fInc(trc.fInc), fPtr(trc.fPtr) { }
227  TMatrixTColumn_const<Element>& operator=(const TMatrixTColumn_const<Element>& trc) {
228  if(this != &trc) { fMatrix=trc.fMatrix; fColInd=trc.fColInd; fInc=trc.fInc; fPtr=trc.fPtr; } return *this;}
229  virtual ~TMatrixTColumn_const() { }
230 
231  inline const TMatrixTBase <Element> *GetMatrix () const { return fMatrix; }
232  inline Int_t GetColIndex() const { return fColInd; }
233  inline Int_t GetInc () const { return fInc; }
234  inline const Element *GetPtr () const { return fPtr; }
235  inline const Element &operator ()(Int_t i) const {
236  if (!this->fMatrix) return TMatrixTBase<Element>::NaNValue();
237  R__ASSERT(fMatrix->IsValid());
238  const Int_t arown = i-fMatrix->GetRowLwb();
239  if (arown < fMatrix->GetNrows() && arown >= 0)
240  return fPtr[arown*fInc];
241  else {
242  Error("operator()","Request row(%d) outside matrix range of %d - %d",
243  i,fMatrix->GetRowLwb(),fMatrix->GetRowLwb()+fMatrix->GetNrows());
244  return TMatrixTBase<Element>::NaNValue();
245  }
246  }
247  inline const Element &operator [](Int_t i) const { return (*(const TMatrixTColumn_const<Element> *)this)(i); }
248 
249  ClassDef(TMatrixTColumn_const,0) // Template of General Matrix Column Access class
250 };
251 
252 template<class Element> class TMatrixTColumn : public TMatrixTColumn_const<Element> {
253 
254 public:
255  TMatrixTColumn() {}
256  TMatrixTColumn(TMatrixT <Element>&matrix,Int_t col);
257  TMatrixTColumn(TMatrixTSym<Element>&matrix,Int_t col);
258  TMatrixTColumn(const TMatrixTColumn <Element>&mc);
259 
260  inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
261 
262  inline const Element &operator()(Int_t i) const {
263  if (!this->fMatrix) return TMatrixTBase<Element>::NaNValue();
264  R__ASSERT(this->fMatrix->IsValid());
265  const Int_t arown = i-this->fMatrix->GetRowLwb();
266  if (arown < this->fMatrix->GetNrows() && arown >= 0)
267  return (this->fPtr)[arown*this->fInc];
268  else {
269  Error("operator()","Request row(%d) outside matrix range of %d - %d",
270  i,this->fMatrix->GetRowLwb(),this->fMatrix->GetRowLwb()+this->fMatrix->GetNrows());
271  return TMatrixTBase<Element>::NaNValue();
272  }
273  }
274  inline Element &operator()(Int_t i) {
275  if (!this->fMatrix) return TMatrixTBase<Element>::NaNValue();
276  R__ASSERT(this->fMatrix->IsValid());
277  const Int_t arown = i-this->fMatrix->GetRowLwb();
278 
279  if (arown < this->fMatrix->GetNrows() && arown >= 0)
280  return (const_cast<Element *>(this->fPtr))[arown*this->fInc];
281  else {
282  Error("operator()","Request row(%d) outside matrix range of %d - %d",
283  i,this->fMatrix->GetRowLwb(),this->fMatrix->GetRowLwb()+this->fMatrix->GetNrows());
284  return TMatrixTBase<Element>::NaNValue();
285  }
286  }
287  inline const Element &operator[](Int_t i) const { return (*(const TMatrixTColumn<Element> *)this)(i); }
288  inline Element &operator[](Int_t i) { return (*( TMatrixTColumn<Element> *)this)(i); }
289 
290  void operator= (Element val);
291  void operator+=(Element val);
292  void operator*=(Element val);
293 
294  void operator=(const TMatrixTColumn_const<Element> &c);
295  TMatrixTColumn<Element>& operator=(const TMatrixTColumn <Element> &c) { operator=((TMatrixTColumn_const<Element> &)c); return *this;}
296  void operator=(const TVectorT <Element> &vec);
297 
298  void operator+=(const TMatrixTColumn_const<Element> &c);
299  void operator*=(const TMatrixTColumn_const<Element> &c);
300 
301  ClassDef(TMatrixTColumn,0) // Template of General Matrix Column Access class
302 };
303 
304 //////////////////////////////////////////////////////////////////////////
305 // //
306 // TMatrixTDiag_const //
307 // //
308 // Template class represents the diagonal of a TMatrixT/TMatrixTSym //
309 // //
310 //////////////////////////////////////////////////////////////////////////
311 
312 template<class Element> class TMatrixTDiag_const {
313 
314 protected:
315  const TMatrixTBase<Element> *fMatrix; // the matrix I am the diagonal of
316  Int_t fInc; // if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]
317  Int_t fNdiag; // number of diag elems, min(nrows,ncols)
318  const Element *fPtr; // pointer to the a[0,0]
319 
320 public:
321  TMatrixTDiag_const() { fMatrix = 0; fInc = 0; fNdiag = 0; fPtr = 0; }
322  TMatrixTDiag_const(const TMatrixT <Element> &matrix);
323  TMatrixTDiag_const(const TMatrixTSym<Element> &matrix);
324  TMatrixTDiag_const(const TMatrixTDiag_const<Element>& trc):
325  fMatrix(trc.fMatrix), fInc(trc.fInc), fNdiag(trc.fNdiag), fPtr(trc.fPtr) { }
326  TMatrixTDiag_const<Element>& operator=(const TMatrixTDiag_const<Element>& trc) {
327  if(this != &trc) { fMatrix=trc.fMatrix; fInc=trc.fInc; fNdiag=trc.fNdiag; fPtr=trc.fPtr; } return *this;}
328  virtual ~TMatrixTDiag_const() { }
329 
330  inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
331  inline const Element *GetPtr () const { return fPtr; }
332  inline Int_t GetInc () const { return fInc; }
333  inline const Element &operator ()(Int_t i) const {
334  R__ASSERT(fMatrix->IsValid());
335  if (i < fNdiag && i >= 0)
336  return fPtr[i*fInc];
337  else {
338  Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,fNdiag);
339  return TMatrixTBase<Element>::NaNValue();
340  }
341  }
342  inline const Element &operator [](Int_t i) const { return (*(const TMatrixTDiag_const<Element> *)this)(i); }
343 
344  Int_t GetNdiags() const { return fNdiag; }
345 
346  ClassDef(TMatrixTDiag_const,0) // Template of General Matrix Diagonal Access class
347 };
348 
349 template<class Element> class TMatrixTDiag : public TMatrixTDiag_const<Element> {
350 
351 public:
352  TMatrixTDiag() {}
353  TMatrixTDiag(TMatrixT <Element>&matrix);
354  TMatrixTDiag(TMatrixTSym<Element>&matrix);
355  TMatrixTDiag(const TMatrixTDiag<Element> &md);
356 
357  inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
358 
359  inline const Element &operator()(Int_t i) const {
360  R__ASSERT(this->fMatrix->IsValid());
361  if (i < this->fNdiag && i >= 0)
362  return (this->fPtr)[i*this->fInc];
363  else {
364  Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,this->fNdiag);
365  return TMatrixTBase<Element>::NaNValue();
366  }
367  }
368  inline Element &operator()(Int_t i) {
369  R__ASSERT(this->fMatrix->IsValid());
370  if (i < this->fNdiag && i >= 0)
371  return (const_cast<Element *>(this->fPtr))[i*this->fInc];
372  else {
373  Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,this->fNdiag);
374  return (const_cast<Element *>(this->fPtr))[0];
375  }
376  }
377  inline const Element &operator[](Int_t i) const { return (*(const TMatrixTDiag<Element> *)this)(i); }
378  inline Element &operator[](Int_t i) { return (*( TMatrixTDiag *)this)(i); }
379 
380  void operator= (Element val);
381  void operator+=(Element val);
382  void operator*=(Element val);
383 
384  void operator=(const TMatrixTDiag_const<Element> &d);
385  TMatrixTDiag<Element>& operator=(const TMatrixTDiag <Element> &d) { operator=((TMatrixTDiag_const<Element> &)d); return *this;}
386  void operator=(const TVectorT <Element> &vec);
387 
388  void operator+=(const TMatrixTDiag_const<Element> &d);
389  void operator*=(const TMatrixTDiag_const<Element> &d);
390 
391  ClassDef(TMatrixTDiag,0) // Template of General Matrix Diagonal Access class
392 };
393 
394 //////////////////////////////////////////////////////////////////////////
395 // //
396 // TMatrixTFlat_const //
397 // //
398 // Template class represents a flat TMatrixT/TMatrixTSym //
399 // //
400 //////////////////////////////////////////////////////////////////////////
401 
402 template<class Element> class TMatrixTFlat_const {
403 
404 protected:
405  const TMatrixTBase<Element> *fMatrix; // the matrix I am the diagonal of
406  Int_t fNelems; //
407  const Element *fPtr; // pointer to the a[0,0]
408 
409 public:
410  TMatrixTFlat_const() { fMatrix = 0; fNelems = 0; fPtr = 0; }
411  TMatrixTFlat_const(const TMatrixT <Element> &matrix);
412  TMatrixTFlat_const(const TMatrixTSym<Element> &matrix);
413  TMatrixTFlat_const(const TMatrixTFlat_const<Element>& trc):
414  fMatrix(trc.fMatrix), fNelems(trc.fNelems), fPtr(trc.fPtr) { }
415  TMatrixTFlat_const<Element>& operator=(const TMatrixTFlat_const<Element>& trc) {
416  if(this != &trc) { fMatrix=trc.fMatrix; fNelems=trc.fNelems; fPtr=trc.fPtr; } return *this;}
417  virtual ~TMatrixTFlat_const() { }
418 
419  inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
420  inline const Element *GetPtr () const { return fPtr; }
421  inline const Element &operator ()(Int_t i) const {
422  R__ASSERT(fMatrix->IsValid());
423  if (i < fNelems && i >= 0)
424  return fPtr[i];
425  else {
426  Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,fNelems);
427  return TMatrixTBase<Element>::NaNValue();
428  }
429  }
430  inline const Element &operator [](Int_t i) const { return (*(const TMatrixTFlat_const<Element> *)this)(i); }
431 
432  ClassDef(TMatrixTFlat_const,0) // Template of General Matrix Flat Representation class
433 };
434 
435 template<class Element> class TMatrixTFlat : public TMatrixTFlat_const<Element> {
436 
437 public:
438  TMatrixTFlat() {}
439  TMatrixTFlat(TMatrixT <Element> &matrix);
440  TMatrixTFlat(TMatrixTSym<Element> &matrix);
441  TMatrixTFlat(const TMatrixTFlat<Element> &mf);
442 
443  inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
444 
445  inline const Element &operator()(Int_t i) const {
446  R__ASSERT(this->fMatrix->IsValid());
447  if (i < this->fNelems && i >= 0)
448  return (this->fPtr)[i];
449  else {
450  Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,this->fNelems);
451  return TMatrixTBase<Element>::NaNValue();
452  }
453  }
454  inline Element &operator()(Int_t i) {
455  R__ASSERT(this->fMatrix->IsValid());
456  if (i < this->fNelems && i >= 0)
457  return (const_cast<Element *>(this->fPtr))[i];
458  else {
459  Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,this->fNelems);
460  return TMatrixTBase<Element>::NaNValue();
461  }
462  }
463  inline const Element &operator[](Int_t i) const { return (*(const TMatrixTFlat<Element> *)this)(i); }
464  inline Element &operator[](Int_t i) { return (*( TMatrixTFlat<Element> *)this)(i); }
465 
466  void operator= (Element val);
467  void operator+=(Element val);
468  void operator*=(Element val);
469 
470  void operator=(const TMatrixTFlat_const<Element> &f);
471  TMatrixTFlat<Element>& operator=(const TMatrixTFlat <Element> &f) { operator=((TMatrixTFlat_const<Element> &)f); return *this;}
472  void operator=(const TVectorT <Element> &vec);
473 
474  void operator+=(const TMatrixTFlat_const<Element> &f);
475  void operator*=(const TMatrixTFlat_const<Element> &f);
476 
477  ClassDef(TMatrixTFlat,0) // Template of General Matrix Flat Representation class
478 };
479 
480 //////////////////////////////////////////////////////////////////////////
481 // //
482 // TMatrixTSub_const //
483 // //
484 // Template class represents a sub matrix of TMatrixT/TMatrixTSym //
485 // //
486 //////////////////////////////////////////////////////////////////////////
487 
488 template<class Element> class TMatrixTSub_const {
489 
490 protected:
491  const TMatrixTBase<Element> *fMatrix; // the matrix I am a submatrix of
492  Int_t fRowOff; //
493  Int_t fColOff; //
494  Int_t fNrowsSub; //
495  Int_t fNcolsSub; //
496 
497 public:
498  TMatrixTSub_const() { fRowOff = fColOff = fNrowsSub = fNcolsSub = 0; fMatrix = 0; }
499  TMatrixTSub_const(const TMatrixT <Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
500  TMatrixTSub_const(const TMatrixTSym<Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
501  virtual ~TMatrixTSub_const() { }
502 
503  inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
504  inline Int_t GetRowOff() const { return fRowOff; }
505  inline Int_t GetColOff() const { return fColOff; }
506  inline Int_t GetNrows () const { return fNrowsSub; }
507  inline Int_t GetNcols () const { return fNcolsSub; }
508  inline const Element &operator ()(Int_t rown,Int_t coln) const {
509  R__ASSERT(fMatrix->IsValid());
510 
511  const Element *ptr = fMatrix->GetMatrixArray();
512  if (rown >= fNrowsSub || rown < 0) {
513  Error("operator()","Request row(%d) outside matrix range of 0 - %d",rown,fNrowsSub);
514  return TMatrixTBase<Element>::NaNValue();
515  }
516  if (coln >= fNcolsSub || coln < 0) {
517  Error("operator()","Request column(%d) outside matrix range of 0 - %d",coln,fNcolsSub);
518  return TMatrixTBase<Element>::NaNValue();
519  }
520  const Int_t index = (rown+fRowOff)*fMatrix->GetNcols()+coln+fColOff;
521  return ptr[index];
522  }
523 
524  ClassDef(TMatrixTSub_const,0) // Template of Sub Matrix Access class
525 };
526 
527 template<class Element> class TMatrixTSub : public TMatrixTSub_const<Element> {
528 
529 public:
530 
531  enum {kWorkMax = 100};
532 
533  TMatrixTSub() {}
534  TMatrixTSub(TMatrixT <Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
535  TMatrixTSub(TMatrixTSym<Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
536  TMatrixTSub(const TMatrixTSub<Element> &ms);
537 
538  inline Element &operator()(Int_t rown,Int_t coln) {
539  R__ASSERT(this->fMatrix->IsValid());
540 
541  const Element *ptr = this->fMatrix->GetMatrixArray();
542  if (rown >= this->fNrowsSub || rown < 0) {
543  Error("operator()","Request row(%d) outside matrix range of 0 - %d",rown,this->fNrowsSub);
544  return TMatrixTBase<Element>::NaNValue();
545  }
546  if (coln >= this->fNcolsSub || coln < 0) {
547  Error("operator()","Request column(%d) outside matrix range of 0 - %d",coln,this->fNcolsSub);
548  return TMatrixTBase<Element>::NaNValue();
549  }
550  const Int_t index = (rown+this->fRowOff)*this->fMatrix->GetNcols()+coln+this->fColOff;
551  return (const_cast<Element *>(ptr))[index];
552  }
553 
554  void Rank1Update(const TVectorT<Element> &vec,Element alpha=1.0);
555 
556  void operator= (Element val);
557  void operator+=(Element val);
558  void operator*=(Element val);
559 
560  void operator=(const TMatrixTSub_const<Element> &s);
561  TMatrixTSub<Element>& operator=(const TMatrixTSub <Element> &s) { operator=((TMatrixTSub_const<Element> &)s); return *this;}
562  void operator=(const TMatrixTBase <Element> &m);
563 
564  void operator+=(const TMatrixTSub_const<Element> &s);
565  void operator*=(const TMatrixTSub_const<Element> &s);
566  void operator+=(const TMatrixTBase <Element> &m);
567  void operator*=(const TMatrixT <Element> &m);
568  void operator*=(const TMatrixTSym <Element> &m);
569 
570  ClassDef(TMatrixTSub,0) // Template of Sub Matrix Access class
571 };
572 
573 //////////////////////////////////////////////////////////////////////////
574 // //
575 // TMatrixTSparseRow_const //
576 // //
577 // Template class represents a row of TMatrixTSparse //
578 // //
579 //////////////////////////////////////////////////////////////////////////
580 
581 template<class Element> class TMatrixTSparseRow_const {
582 
583 protected:
584  const TMatrixTSparse<Element> *fMatrix; // the matrix I am a row of
585  Int_t fRowInd; // effective row index
586  Int_t fNindex; // index range
587  const Int_t *fColPtr; // column index pointer
588  const Element *fDataPtr; // data pointer
589 
590 public:
591  TMatrixTSparseRow_const() { fMatrix = 0; fRowInd = 0; fNindex = 0; fColPtr = 0; fDataPtr = 0; }
592  TMatrixTSparseRow_const(const TMatrixTSparse<Element> &matrix,Int_t row);
593  TMatrixTSparseRow_const(const TMatrixTSparseRow_const<Element>& trc):
594  fMatrix(trc.fMatrix), fRowInd(trc.fRowInd), fNindex(trc.fNindex), fColPtr(trc.fColPtr), fDataPtr(trc.fDataPtr) { }
595  TMatrixTSparseRow_const<Element>& operator=(const TMatrixTSparseRow_const<Element>& trc) {
596  if(this != &trc) { fMatrix=trc.fMatrix; fRowInd=trc.fRowInd; fNindex=trc.fNindex; fColPtr=trc.fColPtr; fDataPtr=trc.fDataPtr; } return *this;}
597  virtual ~TMatrixTSparseRow_const() { }
598 
599  inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
600  inline const Element *GetDataPtr () const { return fDataPtr; }
601  inline const Int_t *GetColPtr () const { return fColPtr; }
602  inline Int_t GetRowIndex() const { return fRowInd; }
603  inline Int_t GetNindex () const { return fNindex; }
604 
605  Element operator()(Int_t i) const;
606  inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }
607 
608  ClassDef(TMatrixTSparseRow_const,0) // Template of Sparse Matrix Row Access class
609 };
610 
611 template<class Element> class TMatrixTSparseRow : public TMatrixTSparseRow_const<Element> {
612 
613 public:
614  TMatrixTSparseRow() {}
615  TMatrixTSparseRow(TMatrixTSparse<Element> &matrix,Int_t row);
616  TMatrixTSparseRow(const TMatrixTSparseRow<Element> &mr);
617 
618  inline Element *GetDataPtr() const { return const_cast<Element *>(this->fDataPtr); }
619 
620  Element operator()(Int_t i) const;
621  Element &operator()(Int_t i);
622  inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseRow<Element> *)this)(i); }
623  inline Element &operator[](Int_t i) { return (*(TMatrixTSparseRow<Element> *)this)(i); }
624 
625  void operator= (Element val);
626  void operator+=(Element val);
627  void operator*=(Element val);
628 
629  void operator=(const TMatrixTSparseRow_const<Element> &r);
630  TMatrixTSparseRow<Element>& operator=(const TMatrixTSparseRow <Element> &r) { operator=((TMatrixTSparseRow_const<Element> &)r); return *this;}
631  void operator=(const TVectorT <Element> &vec);
632 
633  void operator+=(const TMatrixTSparseRow_const<Element> &r);
634  void operator*=(const TMatrixTSparseRow_const<Element> &r);
635 
636  ClassDef(TMatrixTSparseRow,0) // Template of Sparse Matrix Row Access class
637 };
638 
639 //////////////////////////////////////////////////////////////////////////
640 // //
641 // TMatrixTSparseDiag_const //
642 // //
643 // Template class represents the diagonal of TMatrixTSparse //
644 // //
645 //////////////////////////////////////////////////////////////////////////
646 
647 template<class Element> class TMatrixTSparseDiag_const {
648 
649 protected:
650  const TMatrixTSparse<Element> *fMatrix; // the matrix I am the diagonal of
651  Int_t fNdiag; // number of diag elems, min(nrows,ncols)
652  const Element *fDataPtr; // data pointer
653 
654 public:
655  TMatrixTSparseDiag_const() { fMatrix = 0; fNdiag = 0; fDataPtr = 0; }
656  TMatrixTSparseDiag_const(const TMatrixTSparse<Element> &matrix);
657  TMatrixTSparseDiag_const(const TMatrixTSparseDiag_const<Element>& trc):
658  fMatrix(trc.fMatrix), fNdiag(trc.fNdiag), fDataPtr(trc.fDataPtr) { }
659  TMatrixTSparseDiag_const<Element>& operator=(const TMatrixTSparseDiag_const<Element>& trc) {
660  if(this != &trc) { fMatrix=trc.fMatrix; fNdiag=trc.fNdiag; fDataPtr=trc.fDataPtr; } return *this;}
661  virtual ~TMatrixTSparseDiag_const() { }
662 
663  inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
664  inline const Element *GetDataPtr() const { return fDataPtr; }
665  inline Int_t GetNdiags () const { return fNdiag; }
666 
667  Element operator ()(Int_t i) const;
668  inline Element operator [](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }
669 
670  ClassDef(TMatrixTSparseDiag_const,0) // Template of Sparse Matrix Diagonal Access class
671 };
672 
673 template<class Element> class TMatrixTSparseDiag : public TMatrixTSparseDiag_const<Element> {
674 
675 public:
676  TMatrixTSparseDiag() {}
677  TMatrixTSparseDiag(TMatrixTSparse<Element> &matrix);
678  TMatrixTSparseDiag(const TMatrixTSparseDiag<Element> &md);
679 
680  inline Element *GetDataPtr() const { return const_cast<Element *>(this->fDataPtr); }
681 
682  Element operator()(Int_t i) const;
683  Element &operator()(Int_t i);
684  inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseDiag<Element> *)this)(i); }
685  inline Element &operator[](Int_t i) { return (*(TMatrixTSparseDiag<Element> *)this)(i); }
686 
687  void operator= (Element val);
688  void operator+=(Element val);
689  void operator*=(Element val);
690 
691  void operator=(const TMatrixTSparseDiag_const<Element> &d);
692  TMatrixTSparseDiag<Element>& operator=(const TMatrixTSparseDiag <Element> &d) { operator=((TMatrixTSparseDiag_const<Element> &)d); return *this;}
693  void operator=(const TVectorT <Element> &vec);
694 
695  void operator+=(const TMatrixTSparseDiag_const<Element> &d);
696  void operator*=(const TMatrixTSparseDiag_const<Element> &d);
697 
698  ClassDef(TMatrixTSparseDiag,0) // Template of Sparse Matrix Diagonal Access class
699 };
700 
701 Double_t Drand(Double_t &ix);
702 #endif
TMatrixTSparseDiag_const::operator[]
Element operator[](Int_t i) const
Definition: TMatrixTUtils.h:668
TMatrixTBase::GetRowLwb
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:132
TMatrixTSub::Rank1Update
void Rank1Update(const TVectorT< Element > &vec, Element alpha=1.0)
Perform a rank 1 operation on the matrix: A += alpha * v * v^T.
Definition: TMatrixTUtils.cxx:925
TMatrixTSparseDiag_const::fMatrix
const TMatrixTSparse< Element > * fMatrix
Definition: TMatrixTUtils.h:650
TMatrixTSparseRow_const::operator()
Element operator()(Int_t i) const
Definition: TMatrixTUtils.cxx:1362
TMatrixTSparseDiag_const::operator=
TMatrixTSparseDiag_const< Element > & operator=(const TMatrixTSparseDiag_const< Element > &trc)
Definition: TMatrixTUtils.h:659
TMatrixTBase::GetMatrixArray
virtual const Element * GetMatrixArray() const =0
TMatrixTRow_const::fInc
Int_t fInc
Definition: TMatrixTUtils.h:119
TMatrixTRow::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:188
TMatrixTDiag::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:359
TMatrixTSub_const::GetNrows
Int_t GetNrows() const
Definition: TMatrixTUtils.h:506
TMatrixTFlat::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:463
TMatrixTDiag::operator()
Element & operator()(Int_t i)
Definition: TMatrixTUtils.h:368
TMatrixTColumn::GetPtr
Element * GetPtr() const
Definition: TMatrixTUtils.h:260
TMatrixTRow_const::GetRowIndex
Int_t GetRowIndex() const
Definition: TMatrixTUtils.h:133
TMatrixTColumn::operator+=
void operator+=(Element val)
Add val to every element of the matrix column.
Definition: TMatrixTUtils.cxx:323
TMatrixTDiag_const::TMatrixTDiag_const
TMatrixTDiag_const()
Definition: TMatrixTUtils.h:321
TMatrixTRow::GetPtr
Element * GetPtr() const
Definition: TMatrixTUtils.h:161
TMatrixTRow::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:163
TMatrixTColumn_const
Definition: TMatrixDUtilsfwd.h:38
TMatrixTColumn_const::fPtr
const Element * fPtr
Definition: TMatrixTUtils.h:219
TMatrixTSparseDiag_const::~TMatrixTSparseDiag_const
virtual ~TMatrixTSparseDiag_const()
Definition: TMatrixTUtils.h:661
TMatrixTFlat::operator*=
void operator*=(Element val)
Multiply every element of the matrix with val.
Definition: TMatrixTUtils.cxx:692
TMatrixTFlat_const
Definition: TMatrixDUtilsfwd.h:40
TMatrixTSparseRow::operator=
TMatrixTSparseRow< Element > & operator=(const TMatrixTSparseRow< Element > &r)
Definition: TMatrixTUtils.h:630
TMatrixTSparseDiag_const::TMatrixTSparseDiag_const
TMatrixTSparseDiag_const()
Definition: TMatrixTUtils.h:655
TMatrixTColumn_const::fMatrix
const TMatrixTBase< Element > * fMatrix
Definition: TMatrixTUtils.h:216
TMatrixTFlat_const::TMatrixTFlat_const
TMatrixTFlat_const(const TMatrixTFlat_const< Element > &trc)
Definition: TMatrixTUtils.h:413
TMatrixTDiag::operator+=
void operator+=(Element val)
Assign val to every element of the matrix diagonal.
Definition: TMatrixTUtils.cxx:504
TMatrixTRow_const::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:136
TMatrixTSub::operator*=
void operator*=(Element val)
Multiply every element of the sub matrix by val .
Definition: TMatrixTUtils.cxx:985
TMatrixTFlat::GetPtr
Element * GetPtr() const
Definition: TMatrixTUtils.h:443
R__ASSERT
#define R__ASSERT(e)
Definition: TError.h:98
TMatrixTSparseDiag_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:663
TMatrixTRow_const::fRowInd
Int_t fRowInd
Definition: TMatrixTUtils.h:118
TMatrixTFlat::operator()
Element & operator()(Int_t i)
Definition: TMatrixTUtils.h:454
TMatrixTColumn::operator=
TMatrixTColumn< Element > & operator=(const TMatrixTColumn< Element > &c)
Definition: TMatrixTUtils.h:295
Int_t
int Int_t
Definition: RtypesCore.h:41
TMatrixTSparseDiag::operator=
void operator=(Element val)
Assign val to every element of the matrix diagonal.
Definition: TMatrixTUtils.cxx:1741
TMatrixTColumn_const::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:247
TMatrixTSparseDiag_const::fDataPtr
const Element * fDataPtr
Definition: TMatrixTUtils.h:652
TMatrixTSparseRow::operator+=
void operator+=(Element val)
Add val to every non-zero (!) element of the matrix row.
Definition: TMatrixTUtils.cxx:1471
TMatrixTRow::operator()
Element & operator()(Int_t i)
Definition: TMatrixTUtils.h:175
TMatrixTRow::operator*=
void operator*=(Element val)
Multiply every element of the matrix row with val.
Definition: TMatrixTUtils.cxx:139
TMatrixTSparseRow_const::operator=
TMatrixTSparseRow_const< Element > & operator=(const TMatrixTSparseRow_const< Element > &trc)
Definition: TMatrixTUtils.h:595
TMatrixTSub_const::fNrowsSub
Int_t fNrowsSub
Definition: TMatrixTUtils.h:494
TMatrixTSub::operator=
TMatrixTSub< Element > & operator=(const TMatrixTSub< Element > &s)
Definition: TMatrixTUtils.h:561
TMatrixTSparseRow_const::GetNindex
Int_t GetNindex() const
Definition: TMatrixTUtils.h:603
TMatrixTSub_const::operator()
const Element & operator()(Int_t rown, Int_t coln) const
Definition: TMatrixTUtils.h:508
TMatrixTRow_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:132
TMatrixTSub_const::GetNcols
Int_t GetNcols() const
Definition: TMatrixTUtils.h:507
TMatrixTSub::operator()
Element & operator()(Int_t rown, Int_t coln)
Definition: TMatrixTUtils.h:538
TMatrixTSparseRow_const::fRowInd
Int_t fRowInd
Definition: TMatrixTUtils.h:585
TMatrixTColumn_const::TMatrixTColumn_const
TMatrixTColumn_const()
Definition: TMatrixTUtils.h:222
TMatrixTSparseDiag::operator[]
Element operator[](Int_t i) const
Definition: TMatrixTUtils.h:684
TMatrixTDiag_const::operator=
TMatrixTDiag_const< Element > & operator=(const TMatrixTDiag_const< Element > &trc)
Definition: TMatrixTUtils.h:326
TMatrixTBase::IsValid
Bool_t IsValid() const
Definition: TMatrixTBase.h:157
TElementPosActionT::~TElementPosActionT
virtual ~TElementPosActionT()
Definition: TMatrixTUtils.h:99
TMatrixTFlat_const::TMatrixTFlat_const
TMatrixTFlat_const()
Definition: TMatrixTUtils.h:410
TMatrixTDiag_const::fPtr
const Element * fPtr
Definition: TMatrixTUtils.h:318
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:254
TMatrixTSparseRow_const::TMatrixTSparseRow_const
TMatrixTSparseRow_const()
Definition: TMatrixTUtils.h:591
TMatrixTSparseDiag::operator()
Element operator()(Int_t i) const
Definition: TMatrixTUtils.cxx:1677
TElementActionT::Operation
virtual void Operation(Element &element) const =0
TMatrixTSparseDiag_const::TMatrixTSparseDiag_const
TMatrixTSparseDiag_const(const TMatrixTSparseDiag_const< Element > &trc)
Definition: TMatrixTUtils.h:657
TMatrixTDiag_const::fMatrix
const TMatrixTBase< Element > * fMatrix
Definition: TMatrixTUtils.h:315
TMatrixTSparseRow::operator()
Element operator()(Int_t i) const
Definition: TMatrixTUtils.cxx:1400
TMatrixTSparseRow::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:623
TMatrixTSparseDiag::operator*=
void operator*=(Element val)
Multiply every element of the matrix diagonal by val.
Definition: TMatrixTUtils.cxx:1763
TMatrixTSparseRow_const::fColPtr
const Int_t * fColPtr
Definition: TMatrixTUtils.h:587
TMatrixTRow_const::TMatrixTRow_const
TMatrixTRow_const()
Definition: TMatrixTUtils.h:123
TMatrixTFlat::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:445
TMatrixTDiag::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:377
TMatrixTSparseRow_const
Definition: TMatrixDUtilsfwd.h:42
TMatrixTSub_const::TMatrixTSub_const
TMatrixTSub_const()
Definition: TMatrixTUtils.h:498
TMatrixTRow_const::GetInc
Int_t GetInc() const
Definition: TMatrixTUtils.h:134
TMatrixTSparseDiag::operator=
TMatrixTSparseDiag< Element > & operator=(const TMatrixTSparseDiag< Element > &d)
Definition: TMatrixTUtils.h:692
TMatrixTDiag_const::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:333
TMatrixTSparseRow_const::fDataPtr
const Element * fDataPtr
Definition: TMatrixTUtils.h:588
TMatrixTSparseDiag::GetDataPtr
Element * GetDataPtr() const
Definition: TMatrixTUtils.h:680
TMatrixTSub_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:503
Error
void Error(const char *location, const char *msgfmt,...)
TMatrixTSub_const::fNcolsSub
Int_t fNcolsSub
Definition: TMatrixTUtils.h:495
TMatrixTSub_const::~TMatrixTSub_const
virtual ~TMatrixTSub_const()
Definition: TMatrixTUtils.h:501
TMatrixTBase::GetNrows
Int_t GetNrows() const
Definition: TMatrixTBase.h:134
TMatrixTColumn::operator=
void operator=(Element val)
Assign val to every element of the matrix column.
Definition: TMatrixTUtils.cxx:311
TMatrixTFlat::operator=
void operator=(Element val)
Assign val to every element of the matrix.
Definition: TMatrixTUtils.cxx:668
TMatrixTDiag::operator=
TMatrixTDiag< Element > & operator=(const TMatrixTDiag< Element > &d)
Definition: TMatrixTUtils.h:385
TMatrixTSparseRow_const::GetDataPtr
const Element * GetDataPtr() const
Definition: TMatrixTUtils.h:600
TMatrixTColumn::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:288
TMatrixTSub_const::GetRowOff
Int_t GetRowOff() const
Definition: TMatrixTUtils.h:504
TMatrixTFlat_const::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:430
r
ROOT::R::TRInterface & r
Definition: Object.C:4
TMatrixTColumn_const::operator=
TMatrixTColumn_const< Element > & operator=(const TMatrixTColumn_const< Element > &trc)
Definition: TMatrixTUtils.h:227
TMatrixTSparseRow_const::TMatrixTSparseRow_const
TMatrixTSparseRow_const(const TMatrixTSparseRow_const< Element > &trc)
Definition: TMatrixTUtils.h:593
TMatrixTSub_const::fRowOff
Int_t fRowOff
Definition: TMatrixTUtils.h:492
TMatrixTFlat_const::fNelems
Int_t fNelems
Definition: TMatrixTUtils.h:406
TMatrixTDiag_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:330
TMatrixTSparseRow::operator[]
Element operator[](Int_t i) const
Definition: TMatrixTUtils.h:622
TMatrixTSparseRow_const::operator[]
Element operator[](Int_t i) const
Definition: TMatrixTUtils.h:606
TMatrixTDiag::GetPtr
Element * GetPtr() const
Definition: TMatrixTUtils.h:357
TMatrixTSparseRow_const::GetColPtr
const Int_t * GetColPtr() const
Definition: TMatrixTUtils.h:601
m
TMarker * m
Definition: textangle.C:8
TMatrixTSparseRow::GetDataPtr
Element * GetDataPtr() const
Definition: TMatrixTUtils.h:618
TMatrixTColumn_const::GetColIndex
Int_t GetColIndex() const
Definition: TMatrixTUtils.h:232
TMatrixTColumn::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:262
TMatrixTFlat_const::fPtr
const Element * fPtr
Definition: TMatrixTUtils.h:407
TMatrixTDiag_const
Definition: TMatrixDUtilsfwd.h:39
TMatrixTColumn_const::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:235
TMatrixTRow_const::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:148
TMatrixTColumn_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:231
TMatrixTFlat::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:464
TMatrixTFlat_const::fMatrix
const TMatrixTBase< Element > * fMatrix
Definition: TMatrixTUtils.h:405
TMatrixTSub_const
Definition: TMatrixDUtilsfwd.h:41
TMatrixTBase::GetColLwb
Int_t GetColLwb() const
Definition: TMatrixTBase.h:135
TMatrixTSparseRow_const::GetRowIndex
Int_t GetRowIndex() const
Definition: TMatrixTUtils.h:602
TMatrixTRow::operator=
TMatrixTRow< Element > & operator=(const TMatrixTRow< Element > &r)
Definition: TMatrixTUtils.h:196
TMatrixTSub::operator+=
void operator+=(Element val)
Add val to every element of the sub matrix.
Definition: TMatrixTUtils.cxx:968
TElementActionT::operator=
TElementActionT & operator=(const TElementActionT< Element > &)
Definition: TMatrixTUtils.h:71
TMatrixTRow_const::~TMatrixTRow_const
virtual ~TMatrixTRow_const()
Definition: TMatrixTUtils.h:130
TMatrixTFlat_const::operator()
const Element & operator()(Int_t i) const
Definition: TMatrixTUtils.h:421
TMatrixTFlat_const::~TMatrixTFlat_const
virtual ~TMatrixTFlat_const()
Definition: TMatrixTUtils.h:417
TMatrixTFlat_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:419
TMatrixTSub_const::fColOff
Int_t fColOff
Definition: TMatrixTUtils.h:493
TMatrixTFlat::operator+=
void operator+=(Element val)
Add val to every element of the matrix.
Definition: TMatrixTUtils.cxx:680
TMatrixTRow::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:189
TMatrixTRow_const::operator=
TMatrixTRow_const< Element > & operator=(const TMatrixTRow_const< Element > &trc)
Definition: TMatrixTUtils.h:128
TMatrixTSub::operator=
void operator=(Element val)
Assign val to every element of the sub matrix.
Definition: TMatrixTUtils.cxx:951
f
double f(double x)
Definition: testIntegration.cxx:12
TMatrixTRow_const::GetPtr
const Element * GetPtr() const
Definition: TMatrixTUtils.h:135
TMatrixTSparseDiag_const::fNdiag
Int_t fNdiag
Definition: TMatrixTUtils.h:651
TMatrixTSparseDiag::operator+=
void operator+=(Element val)
Add val to every element of the matrix diagonal.
Definition: TMatrixTUtils.cxx:1752
Double_t
double Double_t
Definition: RtypesCore.h:55
TMatrixTColumn_const::fInc
Int_t fInc
Definition: TMatrixTUtils.h:218
TMatrixTRow_const::TMatrixTRow_const
TMatrixTRow_const(const TMatrixTRow_const< Element > &trc)
Definition: TMatrixTUtils.h:126
TMatrixTSub_const::GetColOff
Int_t GetColOff() const
Definition: TMatrixTUtils.h:505
TMatrixTBase::GetNcols
Int_t GetNcols() const
Definition: TMatrixTBase.h:137
TMatrixTSparseRow_const::fNindex
Int_t fNindex
Definition: TMatrixTUtils.h:586
TMatrixTColumn::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:287
TMatrixTFlat_const::GetPtr
const Element * GetPtr() const
Definition: TMatrixTUtils.h:420
TElementPosActionT::Operation
virtual void Operation(Element &element) const =0
TMatrixTSparseRow_const::fMatrix
const TMatrixTSparse< Element > * fMatrix
Definition: TMatrixTUtils.h:584
TElementActionT::~TElementActionT
virtual ~TElementActionT()
Definition: TMatrixTUtils.h:67
TMatrixTRow::operator=
void operator=(Element val)
Assign val to every element of the matrix row.
Definition: TMatrixTUtils.cxx:115
TMatrixTRow_const::fMatrix
const TMatrixTBase< Element > * fMatrix
Definition: TMatrixTUtils.h:117
TMatrixTDiag_const::TMatrixTDiag_const
TMatrixTDiag_const(const TMatrixTDiag_const< Element > &trc)
Definition: TMatrixTUtils.h:324
TMatrixTSparseRow::operator*=
void operator*=(Element val)
Multiply every element of the matrix row by val.
Definition: TMatrixTUtils.cxx:1483
TMatrixTSparseDiag::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:685
TMatrixTColumn_const::GetPtr
const Element * GetPtr() const
Definition: TMatrixTUtils.h:234
sample_config.c
tuple c
Definition: sample_config.py:3
TMatrixTRow_const::fPtr
const Element * fPtr
Definition: TMatrixTUtils.h:120
TMatrixTSparseRow_const::GetMatrix
const TMatrixTBase< Element > * GetMatrix() const
Definition: TMatrixTUtils.h:599
TMatrixTDiag_const::GetPtr
const Element * GetPtr() const
Definition: TMatrixTUtils.h:331
TMatrixTColumn::operator*=
void operator*=(Element val)
Multiply every element of the matrix column with val.
Definition: TMatrixTUtils.cxx:335
TMatrixTColumn_const::GetInc
Int_t GetInc() const
Definition: TMatrixTUtils.h:233
TMatrixTDiag_const::~TMatrixTDiag_const
virtual ~TMatrixTDiag_const()
Definition: TMatrixTUtils.h:328
TMatrixTSparseDiag_const::GetDataPtr
const Element * GetDataPtr() const
Definition: TMatrixTUtils.h:664
TMatrixTSparseDiag_const::operator()
Element operator()(Int_t i) const
Definition: TMatrixTUtils.cxx:1636
TMatrixTBase::NaNValue
static Element & NaNValue()
Definition: TMatrixTBase.cxx:1265
TMatrixTSparseRow::operator=
void operator=(Element val)
Assign val to every non-zero (!) element of the matrix row.
Definition: TMatrixTUtils.cxx:1459
TMatrixTColumn::operator()
Element & operator()(Int_t i)
Definition: TMatrixTUtils.h:274
TMatrixTSparseDiag_const::GetNdiags
Int_t GetNdiags() const
Definition: TMatrixTUtils.h:665
TMatrixTColumn_const::~TMatrixTColumn_const
virtual ~TMatrixTColumn_const()
Definition: TMatrixTUtils.h:229
TMatrixTRow_const
Definition: TMatrixDUtilsfwd.h:37
TMatrixTSparseDiag_const
Definition: TMatrixDUtilsfwd.h:43
TMatrixTSub_const::fMatrix
const TMatrixTBase< Element > * fMatrix
Definition: TMatrixTUtils.h:491
TMatrixTDiag::operator*=
void operator*=(Element val)
Assign val to every element of the matrix diagonal.
Definition: TMatrixTUtils.cxx:516
TMatrixTDiag_const::fNdiag
Int_t fNdiag
Definition: TMatrixTUtils.h:317
TMatrixTColumn_const::TMatrixTColumn_const
TMatrixTColumn_const(const TMatrixTColumn_const< Element > &trc)
Definition: TMatrixTUtils.h:225
TMatrixTSparseRow_const::~TMatrixTSparseRow_const
virtual ~TMatrixTSparseRow_const()
Definition: TMatrixTUtils.h:597
Drand
Double_t Drand(Double_t &ix)
Random number generator [0....1] with seed ix.
Definition: TMatrixTUtils.cxx:1852
TMatrixTRow::operator+=
void operator+=(Element val)
Add val to every element of the matrix row.
Definition: TMatrixTUtils.cxx:127
TMatrixTDiag_const::fInc
Int_t fInc
Definition: TMatrixTUtils.h:316
TMatrixTFlat_const::operator=
TMatrixTFlat_const< Element > & operator=(const TMatrixTFlat_const< Element > &trc)
Definition: TMatrixTUtils.h:415
TMatrixTDiag_const::GetInc
Int_t GetInc() const
Definition: TMatrixTUtils.h:332
TMatrixTDiag::operator[]
Element & operator[](Int_t i)
Definition: TMatrixTUtils.h:378
TMatrixTFlat::operator=
TMatrixTFlat< Element > & operator=(const TMatrixTFlat< Element > &f)
Definition: TMatrixTUtils.h:471
TMatrixTDiag::operator=
void operator=(Element val)
Assign val to every element of the matrix diagonal.
Definition: TMatrixTUtils.cxx:492
TMatrixTDiag_const::GetNdiags
Int_t GetNdiags() const
Definition: TMatrixTUtils.h:344
TMatrixTColumn_const::fColInd
Int_t fColInd
Definition: TMatrixTUtils.h:217
TElementPosActionT::operator=
TElementPosActionT< Element > & operator=(const TElementPosActionT< Element > &)
Definition: TMatrixTUtils.h:103
TMatrixTDiag_const::operator[]
const Element & operator[](Int_t i) const
Definition: TMatrixTUtils.h:342