Logo ROOT   6.08/07
Reference Guide
TMatrixTLazy.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_TMatrixTLazy
13 #define ROOT_TMatrixTLazy
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // Templates of Lazy Matrix classes. //
18 // //
19 // TMatrixTLazy //
20 // TMatrixTSymLazy //
21 // THaarMatrixT //
22 // THilbertMatrixT //
23 // THilbertMatrixTSym //
24 // //
25 //////////////////////////////////////////////////////////////////////////
26 
27 #ifndef ROOT_TMatrixTBase
28 #include "TMatrixTBase.h"
29 #endif
30 
31 template<class Element> class TVectorT;
32 template<class Element> class TMatrixTBase;
33 template<class Element> class TMatrixT;
34 template<class Element> class TMatrixTSym;
35 
36 //////////////////////////////////////////////////////////////////////////
37 // //
38 // TMatrixTLazy //
39 // //
40 // Class used to make a lazy copy of a matrix, i.e. only copy matrix //
41 // when really needed (when accessed). //
42 // //
43 //////////////////////////////////////////////////////////////////////////
44 
45 template<class Element> class TMatrixTLazy : public TObject {
46 
47 friend class TMatrixTBase<Element>;
48 friend class TMatrixT <Element>;
49 friend class TVectorT <Element>;
50 
51 protected:
56 
57  TMatrixTLazy(const TMatrixTLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0),fColUpb(0),fColLwb(0) { }
58  void operator=(const TMatrixTLazy<Element> &) { }
59 
60 private:
61  virtual void FillIn(TMatrixT<Element> &m) const = 0;
62 
63 public:
64  TMatrixTLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }
65  TMatrixTLazy(Int_t nrows, Int_t ncols)
66  : fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }
67  TMatrixTLazy(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)
68  : fRowUpb(row_upb),fRowLwb(row_lwb),fColUpb(col_upb),fColLwb(col_lwb) { }
69  virtual ~TMatrixTLazy() {}
70 
71  inline Int_t GetRowLwb() const { return fRowLwb; }
72  inline Int_t GetRowUpb() const { return fRowUpb; }
73  inline Int_t GetColLwb() const { return fColLwb; }
74  inline Int_t GetColUpb() const { return fColUpb; }
75 
76  ClassDef(TMatrixTLazy,3) // Template of Lazy Matrix class
77 };
78 
79 //////////////////////////////////////////////////////////////////////////
80 // //
81 // TMatrixTSymLazy //
82 // //
83 // Class used to make a lazy copy of a matrix, i.e. only copy matrix //
84 // when really needed (when accessed). //
85 // //
86 //////////////////////////////////////////////////////////////////////////
87 
88 template<class Element> class TMatrixTSymLazy : public TObject {
89 
90 friend class TMatrixTBase<Element>;
91 friend class TMatrixTSym <Element>;
92 friend class TVectorT <Element>;
93 
94 protected:
97 
98  TMatrixTSymLazy(const TMatrixTSymLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0) { }
100 
101 private:
102  virtual void FillIn(TMatrixTSym<Element> &m) const = 0;
103 
104 public:
105  TMatrixTSymLazy() { fRowUpb = fRowLwb = 0; }
107  : fRowUpb(nrows-1),fRowLwb(0) { }
108  TMatrixTSymLazy(Int_t row_lwb,Int_t row_upb)
109  : fRowUpb(row_upb),fRowLwb(row_lwb) { }
110  virtual ~TMatrixTSymLazy() {}
111 
112  inline Int_t GetRowLwb() const { return fRowLwb; }
113  inline Int_t GetRowUpb() const { return fRowUpb; }
114 
115  ClassDef(TMatrixTSymLazy,2) // Template of Lazy Symmeytric class
116 };
117 
118 //////////////////////////////////////////////////////////////////////////
119 // //
120 // THaarMatrixT //
121 // //
122 //////////////////////////////////////////////////////////////////////////
123 
124 template<class Element> class THaarMatrixT: public TMatrixTLazy<Element> {
125 
126 private:
127  void FillIn(TMatrixT<Element> &m) const;
128 
129 public:
131  THaarMatrixT(Int_t n,Int_t no_cols = 0);
132  virtual ~THaarMatrixT() {}
133 
134  ClassDef(THaarMatrixT,2) // Template of Haar Matrix class
135 };
136 
137 //////////////////////////////////////////////////////////////////////////
138 // //
139 // THilbertMatrixT //
140 // //
141 //////////////////////////////////////////////////////////////////////////
142 
143 template<class Element> class THilbertMatrixT : public TMatrixTLazy<Element> {
144 
145 private:
146  void FillIn(TMatrixT<Element> &m) const;
147 
148 public:
150  THilbertMatrixT(Int_t no_rows,Int_t no_cols);
151  THilbertMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
152  virtual ~THilbertMatrixT() {}
153 
154  ClassDef(THilbertMatrixT,2) // Template of Hilbert Matrix class
155 };
156 
157 //////////////////////////////////////////////////////////////////////////
158 // //
159 // THilbertMatrixTSym //
160 // //
161 //////////////////////////////////////////////////////////////////////////
162 
163 template<class Element> class THilbertMatrixTSym : public TMatrixTSymLazy<Element> {
164 
165 private:
166  void FillIn(TMatrixTSym<Element> &m) const;
167 
168 public:
170  THilbertMatrixTSym(Int_t no_rows);
171  THilbertMatrixTSym(Int_t row_lwb,Int_t row_upb);
172  virtual ~THilbertMatrixTSym() {}
173 
174  ClassDef(THilbertMatrixTSym,2) // Template of Symmetric Hilbert Matrix class
175 };
176 
177 #endif
virtual ~THilbertMatrixT()
Definition: TMatrixTLazy.h:152
TVectorT.
Definition: TMatrixTBase.h:89
Int_t GetColUpb() const
Definition: TMatrixTLazy.h:74
virtual ~THaarMatrixT()
Definition: TMatrixTLazy.h:132
void operator=(const TMatrixTLazy< Element > &)
Definition: TMatrixTLazy.h:58
int Int_t
Definition: RtypesCore.h:41
TMatrixTSymLazy(Int_t row_lwb, Int_t row_upb)
Definition: TMatrixTLazy.h:108
TMatrixTLazy(Int_t nrows, Int_t ncols)
Definition: TMatrixTLazy.h:65
TMatrixTLazy(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb)
Definition: TMatrixTLazy.h:67
Int_t GetRowUpb() const
Definition: TMatrixTLazy.h:113
TMatrixT.
Definition: TMatrixDfwd.h:24
TMatrixTSymLazy(const TMatrixTSymLazy< Element > &)
Definition: TMatrixTLazy.h:98
#define ClassDef(name, id)
Definition: Rtypes.h:254
Int_t GetRowLwb() const
Definition: TMatrixTLazy.h:71
TMatrixTSym.
Int_t GetColLwb() const
Definition: TMatrixTLazy.h:73
virtual ~THilbertMatrixTSym()
Definition: TMatrixTLazy.h:172
TMarker * m
Definition: textangle.C:8
void operator=(const TMatrixTSymLazy< Element > &)
Definition: TMatrixTLazy.h:99
Linear Algebra Package.
virtual void FillIn(TMatrixT< Element > &m) const =0
virtual ~TMatrixTLazy()
Definition: TMatrixTLazy.h:69
Mother of all ROOT objects.
Definition: TObject.h:37
Int_t GetRowLwb() const
Definition: TMatrixTLazy.h:112
virtual ~TMatrixTSymLazy()
Definition: TMatrixTLazy.h:110
Int_t GetRowUpb() const
Definition: TMatrixTLazy.h:72
Templates of Lazy Matrix classes.
Definition: TMatrixT.h:38
TMatrixTLazy(const TMatrixTLazy< Element > &)
Definition: TMatrixTLazy.h:57
const Int_t n
Definition: legend1.C:16
TMatrixTSymLazy(Int_t nrows)
Definition: TMatrixTLazy.h:106