Logo ROOT   6.07/09
Reference Guide
TMatrixT.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_TMatrixT
13 #define ROOT_TMatrixT
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // TMatrixT //
18 // //
19 // Template class of a general matrix in the linear algebra package //
20 // //
21 //////////////////////////////////////////////////////////////////////////
22 
23 #ifndef ROOT_TMatrixTBase
24 #include "TMatrixTBase.h"
25 #endif
26 #ifndef ROOT_TMatrixTUtils
27 #include "TMatrixTUtils.h"
28 #endif
29 
30 #ifdef CBLAS
31 #include <vecLib/vBLAS.h>
32 //#include <cblas.h>
33 #endif
34 
35 
36 template<class Element> class TMatrixTSym;
37 template<class Element> class TMatrixTSparse;
38 template<class Element> class TMatrixTLazy;
39 
40 template<class Element> class TMatrixT : public TMatrixTBase<Element> {
41 
42 protected:
43 
44  Element fDataStack[TMatrixTBase<Element>::kSizeMax]; //! data container
45  Element *fElements; //[fNelems] elements themselves
46 
47  Element *New_m (Int_t size);
48  void Delete_m(Int_t size,Element*&);
49  Int_t Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
50  Int_t newSize,Int_t oldSize);
51  void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,Int_t init = 0,
52  Int_t /*nr_nonzeros*/ = -1);
53 
54 
55 public:
56 
57 
58  enum {kWorkMax = 100};
59  enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };
60  enum EMatrixCreatorsOp2 { kMult,kTransposeMult,kInvMult,kMultTranspose,kPlus,kMinus };
61 
62  TMatrixT(): fDataStack(), fElements(0) { }
63  TMatrixT(Int_t nrows,Int_t ncols);
64  TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
65  TMatrixT(Int_t nrows,Int_t ncols,const Element *data,Option_t *option="");
66  TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data,Option_t *option="");
67  TMatrixT(const TMatrixT <Element> &another);
68  TMatrixT(const TMatrixTSym <Element> &another);
69  TMatrixT(const TMatrixTSparse<Element> &another);
70  template <class Element2> TMatrixT(const TMatrixT<Element2> &another): fElements(0)
71  {
72  R__ASSERT(another.IsValid());
73  Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
74  *this = another;
75  }
76 
77  TMatrixT(EMatrixCreatorsOp1 op,const TMatrixT<Element> &prototype);
78  TMatrixT(const TMatrixT <Element> &a,EMatrixCreatorsOp2 op,const TMatrixT <Element> &b);
79  TMatrixT(const TMatrixT <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b);
80  TMatrixT(const TMatrixTSym <Element> &a,EMatrixCreatorsOp2 op,const TMatrixT <Element> &b);
81  TMatrixT(const TMatrixTSym <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b);
82  TMatrixT(const TMatrixTLazy<Element> &lazy_constructor);
83 
84  virtual ~TMatrixT() { Clear(); }
85 
86  // Elementary constructors
87 
88  void Plus (const TMatrixT <Element> &a,const TMatrixT <Element> &b);
89  void Plus (const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
90  void Plus (const TMatrixTSym<Element> &a,const TMatrixT <Element> &b) { Plus(b,a); }
91 
92  void Minus(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
93  void Minus(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
94  void Minus(const TMatrixTSym<Element> &a,const TMatrixT <Element> &b) { Minus(b,a); }
95 
96  void Mult (const TMatrixT <Element> &a,const TMatrixT <Element> &b);
97  void Mult (const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
98  void Mult (const TMatrixTSym<Element> &a,const TMatrixT <Element> &b);
99  void Mult (const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b);
100 
101  void TMult(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
102  void TMult(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
103  void TMult(const TMatrixTSym<Element> &a,const TMatrixT <Element> &b) { Mult(a,b); }
104  void TMult(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }
105 
106  void MultT(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
107  void MultT(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }
108  void MultT(const TMatrixTSym<Element> &a,const TMatrixT <Element> &b);
109  void MultT(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }
110 
111  virtual const Element *GetMatrixArray () const;
112  virtual Element *GetMatrixArray ();
113  virtual const Int_t *GetRowIndexArray() const { return 0; }
114  virtual Int_t *GetRowIndexArray() { return 0; }
115  virtual const Int_t *GetColIndexArray() const { return 0; }
116  virtual Int_t *GetColIndexArray() { return 0; }
117 
118  virtual TMatrixTBase<Element> &SetRowIndexArray(Int_t * /*data*/) { MayNotUse("SetRowIndexArray(Int_t *)"); return *this; }
119  virtual TMatrixTBase<Element> &SetColIndexArray(Int_t * /*data*/) { MayNotUse("SetColIndexArray(Int_t *)"); return *this; }
120 
121  virtual void Clear(Option_t * /*option*/ ="") { if (this->fIsOwner) Delete_m(this->fNelems,fElements);
122  else fElements = 0;
123  this->fNelems = 0; }
124 
125  TMatrixT <Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Element *data);
126  const TMatrixT <Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data) const
127  { return (const TMatrixT<Element>&)
128  ((const_cast<TMatrixT<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb, const_cast<Element *>(data))); }
129  TMatrixT <Element> &Use (Int_t nrows,Int_t ncols,Element *data);
130  const TMatrixT <Element> &Use (Int_t nrows,Int_t ncols,const Element *data) const;
131  TMatrixT <Element> &Use (TMatrixT<Element> &a);
132  const TMatrixT <Element> &Use (const TMatrixT<Element> &a) const;
133 
134  virtual TMatrixTBase<Element> &GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
135  TMatrixTBase<Element> &target,Option_t *option="S") const;
136  TMatrixT <Element> GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
137  virtual TMatrixTBase<Element> &SetSub (Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source);
138 
139  virtual TMatrixTBase<Element> &ResizeTo(Int_t nrows,Int_t ncols,Int_t /*nr_nonzeros*/ =-1);
140  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);
141  inline TMatrixTBase<Element> &ResizeTo(const TMatrixT<Element> &m) {
142  return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),m.GetColUpb());
143  }
144 
145  virtual Double_t Determinant () const;
146  virtual void Determinant (Double_t &d1,Double_t &d2) const;
147 
148  TMatrixT<Element> &Invert (Double_t *det=0);
149  TMatrixT<Element> &InvertFast (Double_t *det=0);
150  TMatrixT<Element> &Transpose (const TMatrixT<Element> &source);
151  inline TMatrixT<Element> &T () { return this->Transpose(*this); }
152  TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v,Element alpha=1.0);
153  TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v1,const TVectorT<Element> &v2,Element alpha=1.0);
154  Element Similarity (const TVectorT<Element> &v) const;
155 
156  TMatrixT<Element> &NormByColumn(const TVectorT<Element> &v,Option_t *option="D");
157  TMatrixT<Element> &NormByRow (const TVectorT<Element> &v,Option_t *option="D");
158 
159  // Either access a_ij as a(i,j)
160  inline Element operator()(Int_t rown,Int_t coln) const;
161  inline Element &operator()(Int_t rown,Int_t coln);
162 
163  // or as a[i][j]
164  inline const TMatrixTRow_const<Element> operator[](Int_t rown) const { return TMatrixTRow_const<Element>(*this,rown); }
165  inline TMatrixTRow <Element> operator[](Int_t rown) { return TMatrixTRow <Element>(*this,rown); }
166 
167  TMatrixT<Element> &operator= (const TMatrixT <Element> &source);
168  TMatrixT<Element> &operator= (const TMatrixTSym <Element> &source);
169  TMatrixT<Element> &operator= (const TMatrixTSparse<Element> &source);
170  TMatrixT<Element> &operator= (const TMatrixTLazy <Element> &source);
171  template <class Element2> TMatrixT<Element> &operator= (const TMatrixT<Element2> &source)
172  {
173  if (!AreCompatible(*this,source)) {
174  Error("operator=(const TMatrixT2 &)","matrices not compatible");
175  return *this;
176  }
177 
178  TObject::operator=(source);
179  const Element2 * const ps = source.GetMatrixArray();
180  Element * const pt = this->GetMatrixArray();
181  for (Int_t i = 0; i < this->fNelems; i++)
182  pt[i] = ps[i];
183  this->fTol = source.GetTol();
184  return *this;
185  }
186 
187  TMatrixT<Element> &operator= (Element val);
188  TMatrixT<Element> &operator-=(Element val);
189  TMatrixT<Element> &operator+=(Element val);
190  TMatrixT<Element> &operator*=(Element val);
191 
192  TMatrixT<Element> &operator+=(const TMatrixT <Element> &source);
193  TMatrixT<Element> &operator+=(const TMatrixTSym<Element> &source);
194  TMatrixT<Element> &operator-=(const TMatrixT <Element> &source);
195  TMatrixT<Element> &operator-=(const TMatrixTSym<Element> &source);
196 
197  TMatrixT<Element> &operator*=(const TMatrixT <Element> &source);
198  TMatrixT<Element> &operator*=(const TMatrixTSym <Element> &source);
199  TMatrixT<Element> &operator*=(const TMatrixTDiag_const <Element> &diag);
200  TMatrixT<Element> &operator/=(const TMatrixTDiag_const <Element> &diag);
201  TMatrixT<Element> &operator*=(const TMatrixTRow_const <Element> &row);
202  TMatrixT<Element> &operator/=(const TMatrixTRow_const <Element> &row);
203  TMatrixT<Element> &operator*=(const TMatrixTColumn_const<Element> &col);
204  TMatrixT<Element> &operator/=(const TMatrixTColumn_const<Element> &col);
205 
206  const TMatrixT<Element> EigenVectors(TVectorT<Element> &eigenValues) const;
207 
208  ClassDef(TMatrixT,4) // Template of General Matrix class
209 };
210 
211 #ifndef __CINT__
212 // When building with -fmodules, it instantiates all pending instantiations,
213 // instead of delaying them until the end of the translation unit.
214 // We 'got away with' probably because the use and the definition of the
215 // explicit specialization do not occur in the same TU.
216 //
217 // In case we are building with -fmodules, we need to forward declare the
218 // specialization in order to compile the dictionary G__Matrix.cxx.
219 template <> TClass *TMatrixT<double>::Class();
220 #endif // __CINT__
221 
222 
223 template <class Element> inline const Element *TMatrixT<Element>::GetMatrixArray() const { return fElements; }
224 template <class Element> inline Element *TMatrixT<Element>::GetMatrixArray() { return fElements; }
225 
226 template <class Element> inline TMatrixT<Element> &TMatrixT<Element>::Use (Int_t nrows,Int_t ncols,Element *data)
227  { return Use(0,nrows-1,0,ncols-1,data); }
228 template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use (Int_t nrows,Int_t ncols,const Element *data) const
229  { return Use(0,nrows-1,0,ncols-1,data); }
230 template <class Element> inline TMatrixT<Element> &TMatrixT<Element>::Use (TMatrixT &a)
231  {
232  R__ASSERT(a.IsValid());
233  return Use(a.GetRowLwb(),a.GetRowUpb(),
234  a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
235  }
236 template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use (const TMatrixT &a) const
237  {
238  R__ASSERT(a.IsValid());
239  return Use(a.GetRowLwb(),a.GetRowUpb(),
240  a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
241  }
242 
243 template <class Element> inline TMatrixT<Element> TMatrixT<Element>::GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
244  Option_t *option) const
245  {
246  TMatrixT tmp;
247  this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
248  return tmp;
249  }
250 
251 template <class Element> inline Element TMatrixT<Element>::operator()(Int_t rown,Int_t coln) const
252 {
253  R__ASSERT(this->IsValid());
254  const Int_t arown = rown-this->fRowLwb;
255  const Int_t acoln = coln-this->fColLwb;
256  if (arown >= this->fNrows || arown < 0) {
257  Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
258  return TMatrixTBase<Element>::NaNValue();
259  }
260  if (acoln >= this->fNcols || acoln < 0) {
261  Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
262  return TMatrixTBase<Element>::NaNValue();
263 
264  }
265  return (fElements[arown*this->fNcols+acoln]);
266 }
267 
268 template <class Element> inline Element &TMatrixT<Element>::operator()(Int_t rown,Int_t coln)
269 {
270  R__ASSERT(this->IsValid());
271  const Int_t arown = rown-this->fRowLwb;
272  const Int_t acoln = coln-this->fColLwb;
273  if (arown >= this->fNrows || arown < 0) {
274  Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
275  return TMatrixTBase<Element>::NaNValue();
276  }
277  if (acoln >= this->fNcols || acoln < 0) {
278  Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
279  return TMatrixTBase<Element>::NaNValue();
280  }
281  return (fElements[arown*this->fNcols+acoln]);
282 }
283 
284 template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
285 template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
286 template <class Element> TMatrixT<Element> operator+ (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
287 template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source , Element val );
288 template <class Element> TMatrixT<Element> operator+ ( Element val ,const TMatrixT <Element> &source );
289 template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
290 template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
291 template <class Element> TMatrixT<Element> operator- (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
292 template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source , Element val );
293 template <class Element> TMatrixT<Element> operator- ( Element val ,const TMatrixT <Element> &source );
294 template <class Element> TMatrixT<Element> operator* ( Element val ,const TMatrixT <Element> &source );
295 template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source , Element val );
296 template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
297 template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
298 template <class Element> TMatrixT<Element> operator* (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
299 template <class Element> TMatrixT<Element> operator* (const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2);
300 // Preventing warnings with -Weffc++ in GCC since overloading the || and && operators was a design choice.
301 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
302 #pragma GCC diagnostic push
303 #pragma GCC diagnostic ignored "-Weffc++"
304 #endif
305 template <class Element> TMatrixT<Element> operator&& (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
306 template <class Element> TMatrixT<Element> operator&& (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
307 template <class Element> TMatrixT<Element> operator&& (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
308 template <class Element> TMatrixT<Element> operator|| (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
309 template <class Element> TMatrixT<Element> operator|| (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
310 template <class Element> TMatrixT<Element> operator|| (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
311 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
312 #pragma GCC diagnostic pop
313 #endif
314 template <class Element> TMatrixT<Element> operator> (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
315 template <class Element> TMatrixT<Element> operator> (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
316 template <class Element> TMatrixT<Element> operator> (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
317 template <class Element> TMatrixT<Element> operator>= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
318 template <class Element> TMatrixT<Element> operator>= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
319 template <class Element> TMatrixT<Element> operator>= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
320 template <class Element> TMatrixT<Element> operator<= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
321 template <class Element> TMatrixT<Element> operator<= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
322 template <class Element> TMatrixT<Element> operator<= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
323 template <class Element> TMatrixT<Element> operator< (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
324 template <class Element> TMatrixT<Element> operator< (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
325 template <class Element> TMatrixT<Element> operator< (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
326 template <class Element> TMatrixT<Element> operator!= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
327 template <class Element> TMatrixT<Element> operator!= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
328 template <class Element> TMatrixT<Element> operator!= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
329 
330 template <class Element> TMatrixT<Element> &Add (TMatrixT<Element> &target, Element scalar,const TMatrixT <Element> &source);
331 template <class Element> TMatrixT<Element> &Add (TMatrixT<Element> &target, Element scalar,const TMatrixTSym<Element> &source);
332 template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixT <Element> &source);
333 template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixTSym<Element> &source);
334 template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixT <Element> &source);
335 template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixTSym<Element> &source);
336 
337 template <class Element> void AMultB (const Element * const ap,Int_t na,Int_t ncolsa,
338  const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
339 template <class Element> void AtMultB(const Element * const ap,Int_t ncolsa,
340  const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
341 template <class Element> void AMultBt(const Element * const ap,Int_t na,Int_t ncolsa,
342  const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
343 
344 #endif
TMatrixTBase::GetRowLwb
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:132
operator-
TMatrixT< Element > operator-(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1-source2
Definition: TMatrixT.cxx:2372
TMatrixT::operator+=
TMatrixT< Element > & operator+=(Element val)
Add val to every element of the matrix.
Definition: TMatrixT.cxx:1842
TMatrixT::NormByColumn
TMatrixT< Element > & NormByColumn(const TVectorT< Element > &v, Option_t *option="D")
Multiply/divide matrix columns by a vector: option: "D" : b(i,j) = a(i,j)/v(i) i = 0...
Definition: TMatrixT.cxx:1642
TMatrixT::Delete_m
void Delete_m(Int_t size, Element *&)
Delete data pointer m, if it was assigned on the heap.
Definition: TMatrixT.cxx:407
TMatrixT::Transpose
TMatrixT< Element > & Transpose(const TMatrixT< Element > &source)
Transpose matrix source.
Definition: TMatrixT.cxx:1469
TMatrixT::TMult
void TMult(const TMatrixTSym< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:104
TMatrixT::TMatrixT
TMatrixT()
Definition: TMatrixT.h:62
TMatrixTBase::fTol
Element fTol
Definition: TMatrixTBase.h:108
Add
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.
Definition: TMatrixT.cxx:2933
TMatrixTBase::GetRowUpb
Int_t GetRowUpb() const
Definition: TMatrixTBase.h:133
Option_t
const char Option_t
Definition: RtypesCore.h:62
operator&&
TMatrixT< Element > operator&&(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
Logical AND.
Definition: TMatrixT.cxx:2483
TMatrixTColumn_const
Definition: TMatrixDUtilsfwd.h:38
TMatrixT::operator*=
TMatrixT< Element > & operator*=(Element val)
Multiply every element of the matrix with val.
Definition: TMatrixT.cxx:1874
TObject::MayNotUse
void MayNotUse(const char *method) const
Use this method to signal that a method (defined in a base class) may not be called in a derived clas...
Definition: TObject.cxx:978
TVectorT
TVectorT.
Definition: TMatrixTBase.h:89
R__ASSERT
#define R__ASSERT(e)
Definition: TError.h:98
TMatrixT::MultT
void MultT(const TMatrixT< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:107
TMatrixT::operator()
Element operator()(Int_t rown, Int_t coln) const
Definition: TMatrixT.h:251
TMatrixT::T
TMatrixT< Element > & T()
Definition: TMatrixT.h:151
Int_t
int Int_t
Definition: RtypesCore.h:41
a
TArc * a
Definition: textangle.C:12
TMatrixT::Allocate
void Allocate(Int_t nrows, Int_t ncols, Int_t row_lwb=0, Int_t col_lwb=0, Int_t init=0, Int_t=-1)
Allocate new matrix.
Definition: TMatrixT.cxx:466
operator*
TMatrixT< Element > operator*(Element val, const TMatrixT< Element > &source)
operation this = val*source
Definition: TMatrixT.cxx:2423
xmlio::Class
const char * Class
Definition: TXMLSetup.cxx:64
TMatrixT::ResizeTo
virtual TMatrixTBase< Element > & ResizeTo(Int_t nrows, Int_t ncols, Int_t=-1)
Set size of the matrix to nrows x ncols New dynamic elements are created, the overlapping part of the...
Definition: TMatrixT.cxx:1210
TMatrixT
TMatrixT.
Definition: TMatrixDfwd.h:24
TMatrixTBase::IsValid
Bool_t IsValid() const
Definition: TMatrixTBase.h:157
TMatrixT::Minus
void Minus(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
General matrix summation. Create a matrix C such that C = A - B.
Definition: TMatrixT.cxx:580
TMatrixTBase::GetTol
Element GetTol() const
Definition: TMatrixTBase.h:139
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:254
operator||
TMatrixT< Element > operator||(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
Logical OR.
Definition: TMatrixT.cxx:2542
TMatrixT::MultT
void MultT(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
General matrix multiplication. Create a matrix C such that C = A * B^T.
Definition: TMatrixT.cxx:951
TMatrixT::New_m
Element * New_m(Int_t size)
Return data pointer .
Definition: TMatrixT.cxx:421
AMultB
void AMultB(const Element *const ap, Int_t na, Int_t ncolsa, const Element *const bp, Int_t nb, Int_t ncolsb, Element *cp)
Elementary routine to calculate matrix multiplication A*B.
Definition: TMatrixT.cxx:3077
TMatrixT::operator-=
TMatrixT< Element > & operator-=(Element val)
Subtract val from every element of the matrix.
Definition: TMatrixT.cxx:1858
operator+
TMatrixT< Element > operator+(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1+source2
Definition: TMatrixT.cxx:2321
TMatrixT::operator/=
TMatrixT< Element > & operator/=(const TMatrixTDiag_const< Element > &diag)
Divide a matrix row by the diagonal of another matrix matrix(i,j) /= diag(j)
Definition: TMatrixT.cxx:2127
TObject::operator=
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.cxx:103
AreCompatible
Bool_t AreCompatible(const TMatrixTBase< Element1 > &m1, const TMatrixTBase< Element2 > &m2, Int_t verbose=0)
Check that matrice sm1 and m2 areboth valid and have identical shapes .
Definition: TMatrixTBase.cxx:1084
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
TMatrixTSym
TMatrixTSym.
Definition: TMatrixDSymfwd.h:24
TMatrixT::TMult
void TMult(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
Create a matrix C such that C = A&#39; * B.
Definition: TMatrixT.cxx:852
TMatrixT::Invert
TMatrixT< Element > & Invert(Double_t *det=0)
Invert the matrix and calculate its determinant.
Definition: TMatrixT.cxx:1396
TMatrixTBase::GetColUpb
Int_t GetColUpb() const
Definition: TMatrixTBase.h:136
TMatrixT::fElements
Element * fElements
data container
Definition: TMatrixT.h:45
TMatrixTBase::GetNrows
Int_t GetNrows() const
Definition: TMatrixTBase.h:134
TMatrixT::operator[]
const TMatrixTRow_const< Element > operator[](Int_t rown) const
Definition: TMatrixT.h:164
TMatrixT::Similarity
Element Similarity(const TVectorT< Element > &v) const
Calculate scalar v * (*this) * v^T.
Definition: TMatrixT.cxx:1601
TMatrixT::Rank1Update
TMatrixT< Element > & Rank1Update(const TVectorT< Element > &v, Element alpha=1.0)
Perform a rank 1 operation on matrix A: A += alpha * v * v^T.
Definition: TMatrixT.cxx:1539
AtMultB
void AtMultB(const Element *const ap, Int_t ncolsa, const Element *const bp, Int_t nb, Int_t ncolsb, Element *cp)
Elementary routine to calculate matrix multiplication A^T*B.
Definition: TMatrixT.cxx:3100
pt
TPaveText * pt
Definition: entrylist_figure1.C:9
v
SVector< double, 2 > v
Definition: Dict.h:5
TMatrixTSparse
TMatrixTSparse.
Definition: TMatrixDSparsefwd.h:24
TMatrixT::EigenVectors
const TMatrixT< Element > EigenVectors(TVectorT< Element > &eigenValues) const
Return a matrix containing the eigen-vectors ordered by descending values of Re^2+Im^2 of the complex...
Definition: TMatrixT.cxx:2307
ElementMult
TMatrixT< Element > & ElementMult(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Multiply target by the source, element-by-element.
Definition: TMatrixT.cxx:2981
m
TMarker * m
Definition: textangle.C:8
TMatrixT::NormByRow
TMatrixT< Element > & NormByRow(const TVectorT< Element > &v, Option_t *option="D")
Multiply/divide matrix rows with a vector: option: "D" : b(i,j) = a(i,j)/v(j) i = 0...
Definition: TMatrixT.cxx:1689
TMatrixTDiag_const
Definition: TMatrixDUtilsfwd.h:39
TMatrixT::SetSub
virtual TMatrixTBase< Element > & SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixTBase< Element > &source)
Insert matrix source starting at [row_lwb][col_lwb], thereby overwriting the part [row_lwb...
Definition: TMatrixT.cxx:1156
TClass
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:81
TMatrixT::GetMatrixArray
virtual const Element * GetMatrixArray() const
Definition: TMatrixT.h:223
TMatrixT::GetColIndexArray
virtual const Int_t * GetColIndexArray() const
Definition: TMatrixT.h:115
TMatrixTBase::GetColLwb
Int_t GetColLwb() const
Definition: TMatrixTBase.h:135
TMatrixTBase
Linear Algebra Package.
Definition: TMatrixDBasefwd.h:27
TMatrixT::GetRowIndexArray
virtual const Int_t * GetRowIndexArray() const
Definition: TMatrixT.h:113
TMatrixT::fDataStack
Element fDataStack[TMatrixTBase< Element >::kSizeMax]
Definition: TMatrixT.h:44
init
static Int_t init()
Definition: RooClassFactory.cxx:54
TMatrixT::Memcpy_m
Int_t Memcpy_m(Element *newp, const Element *oldp, Int_t copySize, Int_t newSize, Int_t oldSize)
Copy copySize doubles from *oldp to *newp .
Definition: TMatrixT.cxx:439
Double_t
double Double_t
Definition: RtypesCore.h:55
TMatrixT::operator[]
TMatrixTRow< Element > operator[](Int_t rown)
Definition: TMatrixT.h:165
TMatrixT::Clear
virtual void Clear(Option_t *="")
Definition: TMatrixT.h:121
TMatrixTBase::operator>=
Bool_t operator>=(Element val) const
Are all matrix elements >= val?
Definition: TMatrixTBase.cxx:980
TMatrixTBase::GetNcols
Int_t GetNcols() const
Definition: TMatrixTBase.h:137
TMatrixT::GetSub
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
Get submatrix [row_lwb..row_upb] x [col_lwb..col_upb]; The indexing range of the returned matrix depe...
Definition: TMatrixT.cxx:1089
TMatrixTBase::fIsOwner
Bool_t fIsOwner
Definition: TMatrixTBase.h:111
TMatrixT::operator=
TMatrixT< Element > & operator=(const TMatrixT< Element > &source)
Assignment operator.
Definition: TMatrixT.cxx:1732
ElementDiv
TMatrixT< Element > & ElementDiv(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Divide target by the source, element-by-element.
Definition: TMatrixT.cxx:3021
TMatrixT::TMatrixT
TMatrixT(const TMatrixT< Element2 > &another)
Definition: TMatrixT.h:70
TMatrixT::Use
const TMatrixT< Element > & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, const Element *data) const
Definition: TMatrixT.h:126
TMatrixT::Use
TMatrixT< Element > & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Element *data)
Use the array data to fill the matrix ([row_lwb..row_upb] x [col_lwb..col_upb])
Definition: TMatrixT.cxx:1053
TMatrixT::Minus
void Minus(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:94
TMatrixT::Plus
void Plus(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
General matrix summation. Create a matrix C such that C = A + B.
Definition: TMatrixT.cxx:512
TMatrixTBase::operator>
Bool_t operator>(Element val) const
Are all matrix elements > val?
Definition: TMatrixTBase.cxx:963
TMatrixT::GetColIndexArray
virtual Int_t * GetColIndexArray()
Definition: TMatrixT.h:116
TMatrixTLazy
Templates of Lazy Matrix classes.
Definition: TMatrixT.h:38
b
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
TMatrixT::~TMatrixT
virtual ~TMatrixT()
Definition: TMatrixT.h:84
TMatrixT::InvertFast
TMatrixT< Element > & InvertFast(Double_t *det=0)
Invert the matrix and calculate its determinant, however upto (6x6) a fast Cramer inversion is used ...
Definition: TMatrixT.cxx:1410
TMatrixT::Determinant
virtual Double_t Determinant() const
Return the matrix determinant.
Definition: TMatrixT.cxx:1361
AMultBt
void AMultBt(const Element *const ap, Int_t na, Int_t ncolsa, const Element *const bp, Int_t nb, Int_t ncolsb, Element *cp)
Elementary routine to calculate matrix multiplication A*B^T.
Definition: TMatrixT.cxx:3124
TMatrixTBase::NaNValue
static Element & NaNValue()
Definition: TMatrixTBase.cxx:1282
TMatrixT::Plus
void Plus(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:90
TMatrixTBase::operator!=
Bool_t operator!=(Element val) const
Are all matrix elements not equal to val?
Definition: TMatrixTBase.cxx:909
TMatrixT::Mult
void Mult(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
General matrix multiplication. Create a matrix C such that C = A * B.
Definition: TMatrixT.cxx:648
TMatrixTRow_const
Definition: TMatrixDUtilsfwd.h:37
TMatrixT::TMult
void TMult(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:103
TMatrixT::MultT
void MultT(const TMatrixTSym< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:109
TMatrixT::SetRowIndexArray
virtual TMatrixTBase< Element > & SetRowIndexArray(Int_t *)
Definition: TMatrixT.h:118
TMatrixT::GetRowIndexArray
virtual Int_t * GetRowIndexArray()
Definition: TMatrixT.h:114
TMatrixT::SetColIndexArray
virtual TMatrixTBase< Element > & SetColIndexArray(Int_t *)
Definition: TMatrixT.h:119
TMatrixT::ResizeTo
TMatrixTBase< Element > & ResizeTo(const TMatrixT< Element > &m)
Definition: TMatrixT.h:141