Logo ROOT  
Reference Guide
TMatrixTBase.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_TMatrixTBase
13 #define ROOT_TMatrixTBase
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // TMatrixTBase //
18 // //
19 // Template of base class in the linear algebra package //
20 // //
21 // matrix properties are stored here, however the data storage is part //
22 // of the derived classes //
23 // //
24 //////////////////////////////////////////////////////////////////////////
25 
26 //======================================================================//
27 // Summary of the streamer version history //
28 //======================================================================//
29 // 3.10/02 4.00/a 4.00/b 4.00/c 4.00-08 5.05-1 //
30 // TMatrixFBase - 2 2 2 4 5 //
31 // TMatrix 2 3 3 3 3 4 //
32 // TMatrixF - 3 3 3 3 4 //
33 // TMatrixFSym - 1 1 1 1 2 //
34 // TMatrixDSparse - - - - - 2 //
35 // //
36 // TMatrixDBase - 2 3 3 4 5 //
37 // TMatrixD 2 3 3 3 3 4 //
38 // TMatrixDSym - 1 1 1 1 2 //
39 // TMatrixDSparse - - 1 1 1 2 //
40 // //
41 // TVector 2 3 3 3 3 4 //
42 // TVectorF - 2 2 2 3 4 //
43 // //
44 // TVectorD 2 2 2 2 3 4 //
45 //======================================================================//
46 // //
47 // 4.00/a : (Jan 25 2004) introduced new classes/inheritance scheme, //
48 // TMatrix now inherits from TMatrixF //
49 // //
50 // TMatrixF::TMatrixFBase //
51 // TMatrixFSym::TMatrixFBase //
52 // TMatrixD::TMatrixDBase //
53 // TMatrixDSym::TMatrixDBase //
54 // //
55 // 4.00/b : (May 12 2004) introduced TMatrixDSparse and added new //
56 // element fNRowIndex to TMatrixFBase and TMatrixDBase //
57 // TMatrixDSparse::TMatrixDBase //
58 // //
59 // 4.00/c : (May 27 2004) Used the TObject::fBits to store validity //
60 // state for vectors and matrices //
61 // //
62 // 5.05-1 : templates TMatrixTBase,TMatrixT,TMatrixTSym and //
63 // TMatrixTSparse were introduced, all versions were //
64 // increased by 1 . //
65 // //
66 //======================================================================//
67 
68 #include "TError.h"
69 #include "TObject.h"
70 #include "TMathBase.h"
71 #include "TMatrixFBasefwd.h"
72 #include "TMatrixDBasefwd.h"
73 #include "TVectorFfwd.h"
74 #include "TVectorDfwd.h"
75 
76 #include <limits>
77 
78 template<class Element> class TVectorT;
79 template<class Element> class TElementActionT;
80 template<class Element> class TElementPosActionT;
81 
83 
84 template<class Element> class TMatrixTBase : public TObject {
85 
86 private:
87  Element *GetElements(); // This function is now obsolete (and is not implemented) you should use TMatrix::GetMatrixArray().
88 
89 protected:
90  Int_t fNrows; // number of rows
91  Int_t fNcols; // number of columns
92  Int_t fRowLwb; // lower bound of the row index
93  Int_t fColLwb; // lower bound of the col index
94  Int_t fNelems; // number of elements in matrix
95  Int_t fNrowIndex; // length of row index array (= fNrows+1) wich is only used for sparse matrices
96 
97  Element fTol; // sqrt(epsilon); epsilon is smallest number number so that 1+epsilon > 1
98  // fTol is used in matrix decomposition (like in inversion)
99 
100  Bool_t fIsOwner; //!default kTRUE, when Use array kFALSE
101 
102  static void DoubleLexSort (Int_t n,Int_t *first,Int_t *second,Element *data);
103  static void IndexedLexSort(Int_t n,Int_t *first,Int_t swapFirst,
104  Int_t *second,Int_t swapSecond,Int_t *index);
105 
106  enum {kSizeMax = 25}; // size data container on stack, see New_m(),Delete_m()
107  enum {kWorkMax = 100}; // size of work array's in several routines
108 
110  kStatus = BIT(14) // set if matrix object is valid
111  };
112 
113 public:
114 
116  fNrows(0), fNcols(0), fRowLwb(0), fColLwb(0), fNelems(0), fNrowIndex(0),
117  fTol(0), fIsOwner(kTRUE) { }
118 
119  virtual ~TMatrixTBase() {}
120 
121  inline Int_t GetRowLwb () const { return fRowLwb; }
122  inline Int_t GetRowUpb () const { return fNrows+fRowLwb-1; }
123  inline Int_t GetNrows () const { return fNrows; }
124  inline Int_t GetColLwb () const { return fColLwb; }
125  inline Int_t GetColUpb () const { return fNcols+fColLwb-1; }
126  inline Int_t GetNcols () const { return fNcols; }
127  inline Int_t GetNoElements () const { return fNelems; }
128  inline Element GetTol () const { return fTol; }
129 
130  virtual const Element *GetMatrixArray () const = 0;
131  virtual Element *GetMatrixArray () = 0;
132  virtual const Int_t *GetRowIndexArray() const = 0;
133  virtual Int_t *GetRowIndexArray() = 0;
134  virtual const Int_t *GetColIndexArray() const = 0;
135  virtual Int_t *GetColIndexArray() = 0;
136 
139  virtual TMatrixTBase<Element> &SetMatrixArray (const Element *data,Option_t *option="");
140  inline Element SetTol (Element tol);
141 
142  virtual void Clear (Option_t *option="") = 0;
143 
144  inline void Invalidate () { SetBit(kStatus); }
145  inline void MakeValid () { ResetBit(kStatus); }
146  inline Bool_t IsValid () const { return !TestBit(kStatus); }
147  inline Bool_t IsOwner () const { return fIsOwner; }
148  virtual Bool_t IsSymmetric() const;
149 
150  virtual TMatrixTBase<Element> &GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
151  TMatrixTBase<Element> &target,Option_t *option="S") const = 0;
152  virtual TMatrixTBase<Element> &SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source) = 0;
153 
154  virtual void GetMatrix2Array(Element *data,Option_t *option="") const;
155  virtual TMatrixTBase<Element> &InsertRow (Int_t row,Int_t col,const Element *v,Int_t n = -1);
156  virtual void ExtractRow (Int_t row,Int_t col, Element *v,Int_t n = -1) const;
157 
158  virtual TMatrixTBase<Element> &Shift (Int_t row_shift,Int_t col_shift);
159  virtual TMatrixTBase<Element> &ResizeTo (Int_t nrows,Int_t ncols,Int_t nr_nonzeros=-1) = 0;
160  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) = 0;
161 
162  virtual Double_t Determinant() const { AbstractMethod("Determinant()"); return 0.; }
163  virtual void Determinant(Double_t &d1,Double_t &d2) const { AbstractMethod("Determinant()"); d1 = 0.; d2 = 0.; }
164 
165  virtual TMatrixTBase<Element> &Zero ();
166  virtual TMatrixTBase<Element> &Abs ();
167  virtual TMatrixTBase<Element> &Sqr ();
168  virtual TMatrixTBase<Element> &Sqrt ();
169  virtual TMatrixTBase<Element> &UnitMatrix ();
170 
171  virtual TMatrixTBase<Element> &NormByDiag (const TVectorT<Element> &v,Option_t *option="D");
172 
173  virtual Element RowNorm () const;
174  virtual Element ColNorm () const;
175  virtual Element E2Norm () const;
176  inline Element NormInf () const { return RowNorm(); }
177  inline Element Norm1 () const { return ColNorm(); }
178  virtual Int_t NonZeros () const;
179  virtual Element Sum () const;
180  virtual Element Min () const;
181  virtual Element Max () const;
182 
183  void Draw (Option_t *option=""); // *MENU*
184  void Print(Option_t *name ="") const; // *MENU*
185 
186  virtual Element operator()(Int_t rown,Int_t coln) const = 0;
187  virtual Element &operator()(Int_t rown,Int_t coln) = 0;
188 
189  Bool_t operator==(Element val) const;
190  Bool_t operator!=(Element val) const;
191  Bool_t operator< (Element val) const;
192  Bool_t operator<=(Element val) const;
193  Bool_t operator> (Element val) const;
194  Bool_t operator>=(Element val) const;
195 
196  virtual TMatrixTBase<Element> &Apply(const TElementActionT<Element> &action);
198 
199  virtual TMatrixTBase<Element> &Randomize(Element alpha,Element beta,Double_t &seed);
200 
201  // make it public since it can be called by TMatrixTRow
202  static Element & NaNValue();
203 
204  ClassDef(TMatrixTBase,5) // Matrix base class (template)
205 };
206 
207 #ifndef __CLING__
208 // When building with -fmodules, it instantiates all pending instantiations,
209 // instead of delaying them until the end of the translation unit.
210 // We 'got away with' probably because the use and the definition of the
211 // explicit specialization do not occur in the same TU.
212 //
213 // In case we are building with -fmodules, we need to forward declare the
214 // specialization in order to compile the dictionary G__Matrix.cxx.
216 #endif // __CLING__
217 
218 
219 template<class Element> Element TMatrixTBase<Element>::SetTol(Element newTol)
220 {
221  const Element oldTol = fTol;
222  if (newTol >= 0.0)
223  fTol = newTol;
224  return oldTol;
225 }
226 
227 template<class Element> Bool_t operator== (const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2);
228 template<class Element> Element E2Norm (const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2);
229 template<class Element1,class Element2>
231 template<class Element> void Compare (const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2);
232 
233 // Service functions (useful in the verification code).
234 // They print some detail info if the validation condition fails
235 
236 template<class Element> Bool_t VerifyMatrixValue (const TMatrixTBase<Element> &m,Element val,
237  Int_t verbose,Element maxDevAllow);
238 template<class Element> Bool_t VerifyMatrixValue (const TMatrixTBase<Element> &m,Element val,Int_t verbose)
239  { return VerifyMatrixValue(m,val,verbose,Element(0.)); }
240 template<class Element> Bool_t VerifyMatrixValue (const TMatrixTBase<Element> &m,Element val)
241  { return VerifyMatrixValue(m,val,1,Element(0.)); }
242 template<class Element> Bool_t VerifyMatrixIdentity(const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2,
243  Int_t verbose,Element maxDevAllow);
245  { return VerifyMatrixIdentity(m1,m2,verbose,Element(0.)); }
247  { return VerifyMatrixIdentity(m1,m2,1,Element(0.)); }
248 
249 #endif
TMatrixTBase::GetRowLwb
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:121
TMatrixTBase::operator==
Bool_t operator==(Element val) const
Are all matrix elements equal to val?
Definition: TMatrixTBase.cxx:693
TMatrixTBase::ExtractRow
virtual void ExtractRow(Int_t row, Int_t col, Element *v, Int_t n=-1) const
Store in array v, n matrix elements of row rown starting at column coln.
Definition: TMatrixTBase.cxx:305
m
auto * m
Definition: textangle.C:8
TMatrixDBasefwd.h
n
const Int_t n
Definition: legend1.C:16
first
Definition: first.py:1
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TMatrixTBase::NaNValue
static Element & NaNValue()
Definition: TMatrixTBase.cxx:1086
TMatrixTBase::fIsOwner
Bool_t fIsOwner
Definition: TMatrixTBase.h:100
TMatrixTBase::operator()
virtual Element operator()(Int_t rown, Int_t coln) const =0
Option_t
const char Option_t
Definition: RtypesCore.h:66
TMatrixTBase::GetRowIndexArray
virtual const Int_t * GetRowIndexArray() const =0
TMatrixTBase::Sqrt
virtual TMatrixTBase< Element > & Sqrt()
Take square root of all elements.
Definition: TMatrixTBase.cxx:399
TMatrixTBase::kSizeMax
@ kSizeMax
Definition: TMatrixTBase.h:106
TMatrixTBase::GetColIndexArray
virtual const Int_t * GetColIndexArray() const =0
gMatrixCheck
R__EXTERN Int_t gMatrixCheck
Definition: TMatrixTBase.h:80
Compare
void Compare(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2)
Compare two matrices and print out the result of the comparison.
Definition: TMatrixTBase.cxx:915
TMatrixTBase::fRowLwb
Int_t fRowLwb
Definition: TMatrixTBase.h:92
TMatrixTBase::MakeValid
void MakeValid()
Definition: TMatrixTBase.h:145
TMatrixTBase::fNrowIndex
Int_t fNrowIndex
Definition: TMatrixTBase.h:95
TMatrixTBase::EMatrixStatusBits
EMatrixStatusBits
Definition: TMatrixTBase.h:109
Int_t
int Int_t
Definition: RtypesCore.h:45
TMatrixTBase::GetMatrixArray
virtual const Element * GetMatrixArray() const =0
TMatrixTBase::fNelems
Int_t fNelems
Definition: TMatrixTBase.h:94
TMatrixTBase::Shift
virtual TMatrixTBase< Element > & Shift(Int_t row_shift, Int_t col_shift)
Shift the row index by adding row_shift and the column index by adding col_shift, respectively.
Definition: TMatrixTBase.cxx:339
TMatrixTBase::SetSub
virtual TMatrixTBase< Element > & SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixTBase< Element > &source)=0
TMatrixTBase::ResizeTo
virtual TMatrixTBase< Element > & ResizeTo(Int_t nrows, Int_t ncols, Int_t nr_nonzeros=-1)=0
TVectorDfwd.h
TMatrixTBase::GetNcols
Int_t GetNcols() const
Definition: TMatrixTBase.h:126
TMatrixTBase::operator>=
Bool_t operator>=(Element val) const
Are all matrix elements >= val?
Definition: TMatrixTBase.cxx:784
TMatrixTBase::IsValid
Bool_t IsValid() const
Definition: TMatrixTBase.h:146
TMatrixTBase::Determinant
virtual void Determinant(Double_t &d1, Double_t &d2) const
Definition: TMatrixTBase.h:163
E2Norm
Element E2Norm(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2)
Square of the Euclidian norm of the difference between two matrices.
Definition: TMatrixTBase.cxx:866
TMatrixTBase::Apply
virtual TMatrixTBase< Element > & Apply(const TElementActionT< Element > &action)
Apply action to each matrix element.
Definition: TMatrixTBase.cxx:801
TMatrixTBase::operator<=
Bool_t operator<=(Element val) const
Are all matrix elements <= val?
Definition: TMatrixTBase.cxx:750
TMatrixTBase::GetNoElements
Int_t GetNoElements() const
Definition: TMatrixTBase.h:127
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TMatrixTBase::IsOwner
Bool_t IsOwner() const
Definition: TMatrixTBase.h:147
TMatrixTBase::DoubleLexSort
static void DoubleLexSort(Int_t n, Int_t *first, Int_t *second, Element *data)
default kTRUE, when Use array kFALSE
Definition: TMatrixTBase.cxx:42
ROOT::Math::beta
double beta(double x, double y)
Calculates the beta function.
Definition: SpecFuncMathCore.cxx:111
TMatrixTBase::fNcols
Int_t fNcols
Definition: TMatrixTBase.h:91
v
@ v
Definition: rootcling_impl.cxx:3635
TMatrixTBase::Clear
virtual void Clear(Option_t *option="")=0
bool
TMatrixTBase::Zero
virtual TMatrixTBase< Element > & Zero()
Set matrix elements to zero.
Definition: TMatrixTBase.cxx:351
TMatrixTBase::NormByDiag
virtual TMatrixTBase< Element > & NormByDiag(const TVectorT< Element > &v, Option_t *option="D")
option:
Definition: TMatrixTBase.cxx:436
TMatrixTBase::GetTol
Element GetTol() const
Definition: TMatrixTBase.h:128
TMatrixTBase::operator<
Bool_t operator<(Element val) const
Are all matrix elements < val?
Definition: TMatrixTBase.cxx:733
TGeant4Unit::m2
static constexpr double m2
Definition: TGeant4SystemOfUnits.h:123
TMatrixTBase::Abs
virtual TMatrixTBase< Element > & Abs()
Take an absolute value of a matrix, i.e. apply Abs() to each element.
Definition: TMatrixTBase.cxx:363
TMatrixTBase::Sum
virtual Element Sum() const
Compute sum of elements.
Definition: TMatrixTBase.cxx:579
TMatrixTBase::SetColIndexArray
virtual TMatrixTBase< Element > & SetColIndexArray(Int_t *data)=0
TMatrixTBase::GetColLwb
Int_t GetColLwb() const
Definition: TMatrixTBase.h:124
TMatrixTBase::operator>
Bool_t operator>(Element val) const
Are all matrix elements > val?
Definition: TMatrixTBase.cxx:767
TMatrixTBase::GetMatrixArray
virtual Element * GetMatrixArray()=0
TMatrixTBase::Invalidate
void Invalidate()
Definition: TMatrixTBase.h:144
TMatrixTBase::GetRowUpb
Int_t GetRowUpb() const
Definition: TMatrixTBase.h:122
TMatrixTBase::NormInf
Element NormInf() const
Definition: TMatrixTBase.h:176
TMatrixTBase::GetRowIndexArray
virtual Int_t * GetRowIndexArray()=0
TMatrixTBase
TMatrixTBase.
Definition: TMatrixTBase.h:84
TMatrixTBase::InsertRow
virtual TMatrixTBase< Element > & InsertRow(Int_t row, Int_t col, const Element *v, Int_t n=-1)
Copy n elements from array v to row rown starting at column coln.
Definition: TMatrixTBase.cxx:271
TMatrixTBase::GetElements
Element * GetElements()
TMatrixTBase::Min
virtual Element Min() const
return minimum matrix element value
Definition: TMatrixTBase.cxx:596
VerifyMatrixValue
Bool_t VerifyMatrixValue(const TMatrixTBase< Element > &m, Element val, Int_t verbose, Element maxDevAllow)
Validate that all elements of matrix have value val within maxDevAllow.
Definition: TMatrixTBase.cxx:969
TMatrixTBase::Class
TClass * Class()
TMatrixTBase::IsSymmetric
virtual Bool_t IsSymmetric() const
Check whether matrix is symmetric.
Definition: TMatrixTBase.cxx:216
BIT
#define BIT(n)
Definition: Rtypes.h:85
TMatrixTBase::GetNrows
Int_t GetNrows() const
Definition: TMatrixTBase.h:123
TMatrixTBase::Print
void Print(Option_t *name="") const
Print the matrix as a table of elements.
Definition: TMatrixTBase.cxx:636
TMatrixTBase::ColNorm
virtual Element ColNorm() const
Column matrix norm, MAX{ SUM{ |M(i,j)|, over i}, over j}.
Definition: TMatrixTBase.cxx:517
TMatrixTBase::SetRowIndexArray
virtual TMatrixTBase< Element > & SetRowIndexArray(Int_t *data)=0
TMatrixTBase::SetTol
Element SetTol(Element tol)
Definition: TMatrixTBase.h:219
TMatrixTBase::operator!=
Bool_t operator!=(Element val) const
Are all matrix elements not equal to val?
Definition: TMatrixTBase.cxx:713
TElementActionT
Definition: TMatrixTUtils.h:56
TVectorT
TVectorT.
Definition: TVectorT.h:27
TMatrixTBase::GetMatrix2Array
virtual void GetMatrix2Array(Element *data, Option_t *option="") const
Copy matrix data to array .
Definition: TMatrixTBase.cxx:245
TMatrixTBase::Norm1
Element Norm1() const
Definition: TMatrixTBase.h:177
Double_t
double Double_t
Definition: RtypesCore.h:59
TObject.h
TMatrixTBase::kStatus
@ kStatus
Definition: TMatrixTBase.h:110
TMatrixTBase::TMatrixTBase
TMatrixTBase()
Definition: TMatrixTBase.h:115
TMatrixTBase::Max
virtual Element Max() const
return maximum vector element value
Definition: TMatrixTBase.cxx:609
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TElementPosActionT
Definition: TMatrixTUtils.h:86
TMatrixTBase::UnitMatrix
virtual TMatrixTBase< Element > & UnitMatrix()
Make a unit matrix (matrix need not be a square one).
Definition: TMatrixTBase.cxx:417
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
AbstractMethod
void AbstractMethod(const char *method)
This function can be used in abstract base classes in case one does not want to make the class a "rea...
Definition: TError.cxx:161
name
char name[80]
Definition: TGX11.cxx:110
TMatrixTBase::ResizeTo
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)=0
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
TMatrixTBase::GetColUpb
Int_t GetColUpb() const
Definition: TMatrixTBase.h:125
TMatrixFBasefwd.h
TMathBase.h
R__EXTERN
#define R__EXTERN
Definition: DllImport.h:27
TVectorFfwd.h
TMatrixTBase::~TMatrixTBase
virtual ~TMatrixTBase()
Definition: TMatrixTBase.h:119
TMatrixTBase::fColLwb
Int_t fColLwb
Definition: TMatrixTBase.h:93
TMatrixTBase::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 =0
TMatrixTBase::Randomize
virtual TMatrixTBase< Element > & Randomize(Element alpha, Element beta, Double_t &seed)
Randomize matrix element values.
Definition: TMatrixTBase.cxx:836
TMatrixTBase::SetMatrixArray
virtual TMatrixTBase< Element > & SetMatrixArray(const Element *data, Option_t *option="")
Copy array data to matrix .
Definition: TMatrixTBase.cxx:188
TMatrixTBase::NonZeros
virtual Int_t NonZeros() const
Compute the number of elements != 0.0.
Definition: TMatrixTBase.cxx:562
TMatrixTBase::IndexedLexSort
static void IndexedLexSort(Int_t n, Int_t *first, Int_t swapFirst, Int_t *second, Int_t swapSecond, Int_t *index)
Lexical sort on array data using indices first and second.
Definition: TMatrixTBase.cxx:81
operator==
Bool_t operator==(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2)
Check to see if two matrices are identical.
Definition: TMatrixTBase.cxx:855
TGeant4Unit::second
static constexpr double second
Definition: TGeant4SystemOfUnits.h:151
TMatrixTBase::E2Norm
virtual Element E2Norm() const
Square of the Euclidian norm, SUM{ m(i,j)^2 }.
Definition: TMatrixTBase.cxx:544
TMatrixTBase::Sqr
virtual TMatrixTBase< Element > & Sqr()
Square each element of the matrix.
Definition: TMatrixTBase.cxx:381
TMatrixTBase::Draw
void Draw(Option_t *option="")
Draw this matrix The histogram is named "TMatrixT" by default and no title.
Definition: TMatrixTBase.cxx:623
TMatrixTBase::Determinant
virtual Double_t Determinant() const
Definition: TMatrixTBase.h:162
TMatrixTBase::RowNorm
virtual Element RowNorm() const
Row matrix norm, MAX{ SUM{ |M(i,j)|, over j}, over i}.
Definition: TMatrixTBase.cxx:490
VerifyMatrixIdentity
Bool_t VerifyMatrixIdentity(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2, Int_t verbose, Element maxDevAllow)
Verify that elements of the two matrices are equal within MaxDevAllow .
Definition: TMatrixTBase.cxx:1012
TMatrixTBase::fTol
Element fTol
Definition: TMatrixTBase.h:97
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:888
TMatrixTBase::operator()
virtual Element & operator()(Int_t rown, Int_t coln)=0
TMatrixTBase::kWorkMax
@ kWorkMax
Definition: TMatrixTBase.h:107
int
TError.h
TMatrixTBase::GetColIndexArray
virtual Int_t * GetColIndexArray()=0
TMatrixTBase::fNrows
Int_t fNrows
Definition: TMatrixTBase.h:90