Logo ROOT  
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#include "TMatrixTBase.h"
24#include "TMatrixTUtils.h"
25
26#ifdef CBLAS
27#include <vecLib/vBLAS.h>
28//#include <cblas.h>
29#endif
30
31#include "Rtypes.h"
32#include "TError.h"
33
34
35template<class Element> class TMatrixTSym;
36template<class Element> class TMatrixTSparse;
37template<class Element> class TMatrixTLazy;
38
39template<class Element> class TMatrixT : public TMatrixTBase<Element> {
40
41protected:
42
43 Element fDataStack[TMatrixTBase<Element>::kSizeMax]; //! data container
44 Element *fElements; //[fNelems] elements themselves
45
46 Element *New_m (Int_t size);
47 void Delete_m(Int_t size,Element*&);
48 Int_t Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
49 Int_t newSize,Int_t oldSize);
50 void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,Int_t init = 0,
51 Int_t /*nr_nonzeros*/ = -1);
52
53
54public:
55
56
57 enum {kWorkMax = 100};
60
61 TMatrixT(): fDataStack(), fElements(nullptr) { }
62 TMatrixT(Int_t nrows,Int_t ncols);
63 TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
64 TMatrixT(Int_t nrows,Int_t ncols,const Element *data,Option_t *option="");
65 TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data,Option_t *option="");
66 TMatrixT(const TMatrixT <Element> &another);
67 TMatrixT(const TMatrixTSym <Element> &another);
68 TMatrixT(const TMatrixTSparse<Element> &another);
69 template <class Element2> TMatrixT(const TMatrixT<Element2> &another): fElements(nullptr)
70 {
71 R__ASSERT(another.IsValid());
72 Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
73 *this = another;
74 }
75
81 TMatrixT(const TMatrixTLazy<Element> &lazy_constructor);
82
83 ~TMatrixT() override { TMatrixT::Clear(); }
84
85 // Elementary constructors
86
87 void Plus (const TMatrixT <Element> &a,const TMatrixT <Element> &b);
88 void Plus (const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
90
91 void Minus(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
94
95 void Mult (const TMatrixT <Element> &a,const TMatrixT <Element> &b);
96 void Mult (const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
97 void Mult (const TMatrixTSym<Element> &a,const TMatrixT <Element> &b);
99
100 void TMult(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
101 void TMult(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b);
104
105 void MultT(const TMatrixT <Element> &a,const TMatrixT <Element> &b);
107 void MultT(const TMatrixTSym<Element> &a,const TMatrixT <Element> &b);
109
110 const Element *GetMatrixArray () const override;
111 Element *GetMatrixArray () override;
112 const Int_t *GetRowIndexArray() const override { return nullptr; }
113 Int_t *GetRowIndexArray() override { return nullptr; }
114 const Int_t *GetColIndexArray() const override { return nullptr; }
115 Int_t *GetColIndexArray() override { return nullptr; }
116
117 TMatrixTBase<Element> &SetRowIndexArray(Int_t * /*data*/) override { MayNotUse("SetRowIndexArray(Int_t *)"); return *this; }
118 TMatrixTBase<Element> &SetColIndexArray(Int_t * /*data*/) override { MayNotUse("SetColIndexArray(Int_t *)"); return *this; }
119
120 void Clear(Option_t * /*option*/ ="") override
121 {
122 if (this->fIsOwner)
123 Delete_m(this->fNelems, fElements);
124 else
125 fElements = nullptr;
126 this->fNelems = 0;
127 }
128
129 TMatrixT <Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Element *data);
130 const TMatrixT <Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data) const
131 { return (const TMatrixT<Element>&)
132 ((const_cast<TMatrixT<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb, const_cast<Element *>(data))); }
133 TMatrixT <Element> &Use (Int_t nrows,Int_t ncols,Element *data);
134 const TMatrixT <Element> &Use (Int_t nrows,Int_t ncols,const Element *data) const;
137
138 TMatrixTBase<Element> &GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
139 TMatrixTBase<Element> &target,Option_t *option="S") const override;
140 TMatrixT <Element> GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
141 TMatrixTBase<Element> &SetSub (Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source) override;
142
143 TMatrixTBase<Element> &ResizeTo(Int_t nrows,Int_t ncols,Int_t /*nr_nonzeros*/ =-1) override;
144 TMatrixTBase<Element> &ResizeTo(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t /*nr_nonzeros*/ =-1) override;
146 return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),m.GetColUpb());
147 }
148
149 Double_t Determinant () const override;
150 void Determinant (Double_t &d1,Double_t &d2) const override;
151
152 TMatrixT<Element> &Invert (Double_t *det = nullptr);
153 TMatrixT<Element> &InvertFast (Double_t *det = nullptr);
155 inline TMatrixT<Element> &T () { return this->Transpose(*this); }
156 TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v,Element alpha=1.0);
157 TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v1,const TVectorT<Element> &v2,Element alpha=1.0);
158 Element Similarity (const TVectorT<Element> &v) const;
159
162
163 // Either access a_ij as a(i,j)
164 inline Element operator()(Int_t rown,Int_t coln) const override;
165 inline Element &operator()(Int_t rown,Int_t coln) override;
166
167 // or as a[i][j]
168 inline const TMatrixTRow_const<Element> operator[](Int_t rown) const { return TMatrixTRow_const<Element>(*this,rown); }
169 inline TMatrixTRow <Element> operator[](Int_t rown) { return TMatrixTRow <Element>(*this,rown); }
170
175 template <class Element2> TMatrixT<Element> &operator= (const TMatrixT<Element2> &source)
176 {
177 if (!AreCompatible(*this,source)) {
178 Error("operator=(const TMatrixT2 &)","matrices not compatible");
179 return *this;
180 }
181
182 TObject::operator=(source);
183 const Element2 * const ps = source.GetMatrixArray();
184 Element * const pt = this->GetMatrixArray();
185 for (Int_t i = 0; i < this->fNelems; i++)
186 pt[i] = ps[i];
187 this->fTol = source.GetTol();
188 return *this;
189 }
190
191 TMatrixT<Element> &operator= (Element val);
192 TMatrixT<Element> &operator-=(Element val);
193 TMatrixT<Element> &operator+=(Element val);
194 TMatrixT<Element> &operator*=(Element val);
195
200
209
210 const TMatrixT<Element> EigenVectors(TVectorT<Element> &eigenValues) const;
211
212 ClassDefOverride(TMatrixT,4) // Template of General Matrix class
213};
214
215#ifndef __CINT__
216// When building with -fmodules, it instantiates all pending instantiations,
217// instead of delaying them until the end of the translation unit.
218// We 'got away with' probably because the use and the definition of the
219// explicit specialization do not occur in the same TU.
220//
221// In case we are building with -fmodules, we need to forward declare the
222// specialization in order to compile the dictionary G__Matrix.cxx.
224#endif // __CINT__
225
226
227template <class Element> inline const Element *TMatrixT<Element>::GetMatrixArray() const { return fElements; }
228template <class Element> inline Element *TMatrixT<Element>::GetMatrixArray() { return fElements; }
229
230template <class Element> inline TMatrixT<Element> &TMatrixT<Element>::Use (Int_t nrows,Int_t ncols,Element *data)
231 { return Use(0,nrows-1,0,ncols-1,data); }
232template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use (Int_t nrows,Int_t ncols,const Element *data) const
233 { return Use(0,nrows-1,0,ncols-1,data); }
234template <class Element> inline TMatrixT<Element> &TMatrixT<Element>::Use (TMatrixT &a)
235 {
236 R__ASSERT(a.IsValid());
237 return Use(a.GetRowLwb(),a.GetRowUpb(),
238 a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
239 }
240template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use (const TMatrixT &a) const
241 {
242 R__ASSERT(a.IsValid());
243 return Use(a.GetRowLwb(),a.GetRowUpb(),
244 a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
245 }
246
247template <class Element> inline TMatrixT<Element> TMatrixT<Element>::GetSub (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
248 Option_t *option) const
249 {
250 TMatrixT tmp;
251 this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
252 return tmp;
253 }
254
255template <class Element> inline Element TMatrixT<Element>::operator()(Int_t rown,Int_t coln) const
256{
257 R__ASSERT(this->IsValid());
258 const Int_t arown = rown-this->fRowLwb;
259 const Int_t acoln = coln-this->fColLwb;
260 if (arown >= this->fNrows || arown < 0) {
261 Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
263 }
264 if (acoln >= this->fNcols || acoln < 0) {
265 Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
267
268 }
269 return (fElements[arown*this->fNcols+acoln]);
270}
271
272template <class Element> inline Element &TMatrixT<Element>::operator()(Int_t rown,Int_t coln)
273{
274 R__ASSERT(this->IsValid());
275 const Int_t arown = rown-this->fRowLwb;
276 const Int_t acoln = coln-this->fColLwb;
277 if (arown >= this->fNrows || arown < 0) {
278 Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
280 }
281 if (acoln >= this->fNcols || acoln < 0) {
282 Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
284 }
285 return (fElements[arown*this->fNcols+acoln]);
286}
287
288inline namespace TMatrixTAutoloadOps {
289
290template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
291template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
292template <class Element> TMatrixT<Element> operator+ (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
293template <class Element> TMatrixT<Element> operator+ (const TMatrixT <Element> &source , Element val );
294template <class Element> TMatrixT<Element> operator+ ( Element val ,const TMatrixT <Element> &source );
295template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
296template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
297template <class Element> TMatrixT<Element> operator- (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
298template <class Element> TMatrixT<Element> operator- (const TMatrixT <Element> &source , Element val );
299template <class Element> TMatrixT<Element> operator- ( Element val ,const TMatrixT <Element> &source );
300template <class Element> TMatrixT<Element> operator* ( Element val ,const TMatrixT <Element> &source );
301template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source , Element val );
302template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
303template <class Element> TMatrixT<Element> operator* (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
304template <class Element> TMatrixT<Element> operator* (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
305template <class Element> TMatrixT<Element> operator* (const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2);
306// Preventing warnings with -Weffc++ in GCC since overloading the || and && operators was a design choice.
307#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
308#pragma GCC diagnostic push
309#pragma GCC diagnostic ignored "-Weffc++"
310#endif
311template <class Element> TMatrixT<Element> operator&& (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
312template <class Element> TMatrixT<Element> operator&& (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
313template <class Element> TMatrixT<Element> operator&& (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
314template <class Element> TMatrixT<Element> operator|| (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
315template <class Element> TMatrixT<Element> operator|| (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
316template <class Element> TMatrixT<Element> operator|| (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
317#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
318#pragma GCC diagnostic pop
319#endif
320template <class Element> TMatrixT<Element> operator> (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
321template <class Element> TMatrixT<Element> operator> (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
322template <class Element> TMatrixT<Element> operator> (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
323template <class Element> TMatrixT<Element> operator>= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
324template <class Element> TMatrixT<Element> operator>= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
325template <class Element> TMatrixT<Element> operator>= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
326template <class Element> TMatrixT<Element> operator<= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
327template <class Element> TMatrixT<Element> operator<= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
328template <class Element> TMatrixT<Element> operator<= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
329template <class Element> TMatrixT<Element> operator< (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
330template <class Element> TMatrixT<Element> operator< (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
331template <class Element> TMatrixT<Element> operator< (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
332template <class Element> TMatrixT<Element> operator!= (const TMatrixT <Element> &source1,const TMatrixT <Element> &source2);
333template <class Element> TMatrixT<Element> operator!= (const TMatrixT <Element> &source1,const TMatrixTSym<Element> &source2);
334template <class Element> TMatrixT<Element> operator!= (const TMatrixTSym<Element> &source1,const TMatrixT <Element> &source2);
335
336template <class Element> TMatrixT<Element> &Add (TMatrixT<Element> &target, Element scalar,const TMatrixT <Element> &source);
337template <class Element> TMatrixT<Element> &Add (TMatrixT<Element> &target, Element scalar,const TMatrixTSym<Element> &source);
338template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixT <Element> &source);
339template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixTSym<Element> &source);
340template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixT <Element> &source);
341template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixTSym<Element> &source);
342
343template <class Element> void AMultB (const Element * const ap,Int_t na,Int_t ncolsa,
344 const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
345template <class Element> void AtMultB(const Element * const ap,Int_t ncolsa,
346 const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
347template <class Element> void AMultBt(const Element * const ap,Int_t na,Int_t ncolsa,
348 const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
349} // inline namespace TMatrixTAutoloadOps
350#endif
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
int Int_t
Definition: RtypesCore.h:45
double Double_t
Definition: RtypesCore.h:59
const char Option_t
Definition: RtypesCore.h:66
#define ClassDefOverride(name, id)
Definition: Rtypes.h:339
#define R__ASSERT(e)
Definition: TError.h:118
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
TMatrixTBase.
Definition: TMatrixTBase.h:84
Int_t GetNrows() const
Definition: TMatrixTBase.h:123
Bool_t fIsOwner
Definition: TMatrixTBase.h:100
Element fTol
Definition: TMatrixTBase.h:97
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:121
Int_t GetColLwb() const
Definition: TMatrixTBase.h:124
static Element & NaNValue()
Bool_t IsValid() const
Definition: TMatrixTBase.h:146
Int_t GetNcols() const
Definition: TMatrixTBase.h:126
Element GetTol() const
Definition: TMatrixTBase.h:128
Templates of Lazy Matrix classes.
Definition: TMatrixTLazy.h:43
TMatrixTSparse.
TMatrixTSym.
Definition: TMatrixTSym.h:34
TMatrixT.
Definition: TMatrixT.h:39
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 override
Get submatrix [row_lwb..row_upb] x [col_lwb..col_upb]; The indexing range of the returned matrix depe...
Definition: TMatrixT.cxx:1090
void MultT(const TMatrixTSym< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:108
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:1540
const TMatrixT< Element > & Use(Int_t nrows, Int_t ncols, const Element *data) const
Definition: TMatrixT.h:232
void TMult(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:102
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:1054
Int_t * GetColIndexArray() override
Definition: TMatrixT.h:115
const TMatrixTRow_const< Element > operator[](Int_t rown) const
Definition: TMatrixT.h:168
void Clear(Option_t *="") override
Definition: TMatrixT.h:120
void Delete_m(Int_t size, Element *&)
Delete data pointer m, if it was assigned on the heap.
Definition: TMatrixT.cxx:408
TMatrixT< Element > & operator*=(Element val)
Multiply every element of the matrix with val.
Definition: TMatrixT.cxx:1875
const Int_t * GetRowIndexArray() const override
Definition: TMatrixT.h:112
TMatrixT< Element > GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t *option="S") const
Definition: TMatrixT.h:247
Element fDataStack[TMatrixTBase< Element >::kSizeMax]
Definition: TMatrixT.h:43
TMatrixT(const TMatrixT< Element2 > &another)
Definition: TMatrixT.h:69
TMatrixT< Element > & Use(TMatrixT< Element > &a)
Definition: TMatrixT.h:234
Element & operator()(Int_t rown, Int_t coln) override
Definition: TMatrixT.h:272
TMatrixT< Element > & T()
Definition: TMatrixT.h:155
TMatrixT< Element > & operator=(const TMatrixT< Element > &source)
Assignment operator.
Definition: TMatrixT.cxx:1733
const TMatrixT< Element > & Use(const TMatrixT< Element > &a) const
Definition: TMatrixT.h:240
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:1690
@ kWorkMax
Definition: TMatrixT.h:57
const Int_t * GetColIndexArray() const override
Definition: TMatrixT.h:114
const Element * GetMatrixArray() const override
Definition: TMatrixT.h:227
void MultT(const TMatrixT< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:106
EMatrixCreatorsOp2
Definition: TMatrixT.h:59
@ kMult
Definition: TMatrixT.h:59
@ kMultTranspose
Definition: TMatrixT.h:59
@ kTransposeMult
Definition: TMatrixT.h:59
@ kInvMult
Definition: TMatrixT.h:59
@ kMinus
Definition: TMatrixT.h:59
@ kPlus
Definition: TMatrixT.h:59
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:581
Element Similarity(const TVectorT< Element > &v) const
Calculate scalar v * (*this) * v^T.
Definition: TMatrixT.cxx:1602
TMatrixT< Element > & Use(Int_t nrows, Int_t ncols, Element *data)
Definition: TMatrixT.h:230
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:513
TMatrixTBase< Element > & ResizeTo(const TMatrixT< Element > &m)
Definition: TMatrixT.h:145
void Minus(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:93
Element operator()(Int_t rown, Int_t coln) const override
Definition: TMatrixT.h:255
TMatrixT< Element > & operator-=(Element val)
Subtract val from every element of the matrix.
Definition: TMatrixT.cxx:1859
Double_t Determinant() const override
Return the matrix determinant.
Definition: TMatrixT.cxx:1362
TMatrixT< Element > & Transpose(const TMatrixT< Element > &source)
Transpose matrix source.
Definition: TMatrixT.cxx:1470
TMatrixTBase< Element > & SetRowIndexArray(Int_t *) override
Definition: TMatrixT.h:117
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:952
TMatrixT< Element > & InvertFast(Double_t *det=nullptr)
Invert the matrix and calculate its determinant, however upto (6x6) a fast Cramer inversion is used .
Definition: TMatrixT.cxx:1411
void TMult(const TMatrixTSym< Element > &a, const TMatrixTSym< Element > &b)
Definition: TMatrixT.h:103
TMatrixTBase< Element > & SetColIndexArray(Int_t *) override
Definition: TMatrixT.h:118
TMatrixTBase< Element > & SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixTBase< Element > &source) override
Insert matrix source starting at [row_lwb][col_lwb], thereby overwriting the part [row_lwb....
Definition: TMatrixT.cxx:1157
Element * New_m(Int_t size)
Return data pointer .
Definition: TMatrixT.cxx:422
EMatrixCreatorsOp1
Definition: TMatrixT.h:58
@ kZero
Definition: TMatrixT.h:58
@ kAtA
Definition: TMatrixT.h:58
@ kUnit
Definition: TMatrixT.h:58
@ kInverted
Definition: TMatrixT.h:58
@ kTransposed
Definition: TMatrixT.h:58
~TMatrixT() override
Definition: TMatrixT.h:83
TMatrixTBase< Element > & ResizeTo(Int_t nrows, Int_t ncols, Int_t=-1) override
Set size of the matrix to nrows x ncols New dynamic elements are created, the overlapping part of the...
Definition: TMatrixT.cxx:1211
TMatrixT< Element > & Invert(Double_t *det=nullptr)
Invert the matrix and calculate its determinant.
Definition: TMatrixT.cxx:1397
TMatrixTRow< Element > operator[](Int_t rown)
Definition: TMatrixT.h:169
Int_t * GetRowIndexArray() override
Definition: TMatrixT.h:113
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:467
TMatrixT()
Definition: TMatrixT.h:61
void Plus(const TMatrixTSym< Element > &a, const TMatrixT< Element > &b)
Definition: TMatrixT.h:89
TMatrixT< Element > & operator+=(Element val)
Add val to every element of the matrix.
Definition: TMatrixT.cxx:1843
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:1643
void TMult(const TMatrixT< Element > &a, const TMatrixT< Element > &b)
Create a matrix C such that C = A' * B.
Definition: TMatrixT.cxx:853
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:2308
static TClass * Class()
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:649
Element * fElements
data container
Definition: TMatrixT.h:44
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:440
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:2128
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:130
Element * GetMatrixArray() override
Definition: TMatrixT.h:228
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:298
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:1016
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:963
TVectorT.
Definition: TVectorT.h:27
TPaveText * pt
void init()
Inspect hardware capabilities, and load the optimal library for RooFit computations.
static constexpr double ps
TMatrixT< Element > operator!=(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
logical operation source1 != source2
Definition: TMatrixT.cxx:2844
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:3125
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:3078
TMatrixT< Element > operator+(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1+source2
Definition: TMatrixT.cxx:2322
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:3101
TMatrixT< Element > operator>=(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
logical operation source1 >= source2
Definition: TMatrixT.cxx:2663
TMatrixT< Element > & ElementMult(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Multiply target by the source, element-by-element.
Definition: TMatrixT.cxx:2982
TMatrixT< Element > operator||(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
Logical OR.
Definition: TMatrixT.cxx:2543
TMatrixT< Element > operator<(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
logical operation source1 < source2
Definition: TMatrixT.cxx:2785
TMatrixT< Element > operator>(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
logical operation source1 > source2
Definition: TMatrixT.cxx:2602
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.
Definition: TMatrixT.cxx:2934
TMatrixT< Element > & ElementDiv(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Divide target by the source, element-by-element.
Definition: TMatrixT.cxx:3022
TMatrixT< Element > operator-(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1-source2
Definition: TMatrixT.cxx:2373
TMatrixT< Element > operator<=(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
logical operation source1 <= source2
Definition: TMatrixT.cxx:2724
TMatrixT< Element > operator&&(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
Logical AND.
Definition: TMatrixT.cxx:2484
TMatrixT< Element > operator*(Element val, const TMatrixT< Element > &source)
operation this = val*source
Definition: TMatrixT.cxx:2424
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 .
TMarker m
Definition: textangle.C:8
TArc a
Definition: textangle.C:12