Logo ROOT  
Reference Guide
TVectorT.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_TVectorT
13#define ROOT_TVectorT
14
15//////////////////////////////////////////////////////////////////////////
16// //
17// TVectorT //
18// //
19// Template class of Vectors in the linear algebra package //
20// //
21//////////////////////////////////////////////////////////////////////////
22
23#include "TMatrixT.h"
24#include "TMatrixTSym.h"
25#include "TMatrixTSparse.h"
26
27template<class Element> class TVectorT : public TObject {
28
29protected:
30 Int_t fNrows{0}; // number of rows
31 Int_t fRowLwb{0}; // lower bound of the row index
32 Element *fElements{nullptr}; //[fNrows] elements themselves
33
34 enum {kSizeMax = 5}; // size data container on stack, see New_m(),Delete_m()
35 enum {kWorkMax = 100}; // size of work array's in several routines
36
37 Element fDataStack[kSizeMax]; //! data container
38 Bool_t fIsOwner{kTRUE}; //!default kTRUE, when Use array kFALSE
39
40 Element* New_m (Int_t size);
41 void Delete_m(Int_t size,Element*&);
42 Int_t Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
43 Int_t newSize,Int_t oldSize);
44
45 void Allocate(Int_t nrows,Int_t row_lwb = 0,Int_t init = 0);
46
48 kStatus = BIT(14) // set if vector object is valid
49 };
50
51public:
52
54 explicit TVectorT(Int_t n);
55 TVectorT(Int_t lwb,Int_t upb);
56 TVectorT(Int_t n,const Element *elements);
57 TVectorT(Int_t lwb,Int_t upb,const Element *elements);
58 TVectorT(const TVectorT <Element> &another);
62 template <class Element2> TVectorT(const TVectorT<Element2> &another)
63 {
64 R__ASSERT(another.IsValid());
65 Allocate(another.GetUpb()-another.GetLwb()+1,another.GetLwb());
66 *this = another;
67 }
68#ifndef __CINT__
69 TVectorT(Int_t lwb,Int_t upb,Double_t iv1, ...);
70#endif
71 virtual ~TVectorT() { TVectorT::Clear(); }
72
73 inline Int_t GetLwb () const { return fRowLwb; }
74 inline Int_t GetUpb () const { return fNrows+fRowLwb-1; }
75 inline Int_t GetNrows () const { return fNrows; }
76 inline Int_t GetNoElements() const { return fNrows; }
77
78 inline Element *GetMatrixArray () { return fElements; }
79 inline const Element *GetMatrixArray () const { return fElements; }
80
81 inline void Invalidate () { SetBit(kStatus); }
82 inline void MakeValid () { ResetBit(kStatus); }
83 inline Bool_t IsValid () const { return !TestBit(kStatus); }
84 inline Bool_t IsOwner () const { return fIsOwner; }
85 inline void SetElements(const Element *elements) { R__ASSERT(IsValid());
86 memcpy(fElements,elements,fNrows*sizeof(Element)); }
87 inline TVectorT<Element> &Shift (Int_t row_shift) { fRowLwb += row_shift; return *this; }
89 inline TVectorT<Element> &ResizeTo (Int_t n) { return ResizeTo(0,n-1); }
90 inline TVectorT<Element> &ResizeTo (const TVectorT<Element> &v) { return ResizeTo(v.GetLwb(),v.GetUpb()); }
91
92 TVectorT<Element> &Use (Int_t lwb,Int_t upb,Element *data);
93 const TVectorT<Element> &Use (Int_t lwb,Int_t upb,const Element *data) const
94 { return (const TVectorT<Element>&)(const_cast<TVectorT<Element> *>(this))->Use(lwb,upb,const_cast<Element *>(data)); }
95 TVectorT<Element> &Use (Int_t n,Element *data);
96 const TVectorT<Element> &Use (Int_t n,const Element *data) const ;
98 const TVectorT<Element> &Use (const TVectorT<Element> &v) const ;
99
100 TVectorT<Element> &GetSub (Int_t row_lwb,Int_t row_upb,TVectorT<Element> &target,Option_t *option="S") const;
101 TVectorT<Element> GetSub (Int_t row_lwb,Int_t row_upb,Option_t *option="S") const;
102 TVectorT<Element> &SetSub (Int_t row_lwb,const TVectorT<Element> &source);
103
110
111 Element Norm1 () const;
112 Element Norm2Sqr() const;
113 Element NormInf () const;
114 Int_t NonZeros() const;
115 Element Sum () const;
116 Element Min () const;
117 Element Max () const;
118
119 inline const Element &operator()(Int_t index) const;
120 inline Element &operator()(Int_t index);
121 inline const Element &operator[](Int_t index) const { return (*this)(index); }
122 inline Element &operator[](Int_t index) { return (*this)(index); }
123
130 template <class Element2> TVectorT<Element> &operator= (const TVectorT<Element2> &source)
131 {
132 if (!AreCompatible(*this,source)) {
133 Error("operator=(const TVectorT2 &)","vectors not compatible");
134 return *this;
135 }
136
137 TObject::operator=(source);
138 const Element2 * const ps = source.GetMatrixArray();
139 Element * const pt = GetMatrixArray();
140 for (Int_t i = 0; i < this->fNrows; i++)
141 pt[i] = ps[i];
142 return *this;
143 }
144
145 TVectorT<Element> &operator= (Element val);
146 TVectorT<Element> &operator+=(Element val);
147 TVectorT<Element> &operator-=(Element val);
148 TVectorT<Element> &operator*=(Element val);
149
155
156 Bool_t operator==(Element val) const;
157 Bool_t operator!=(Element val) const;
158 Bool_t operator< (Element val) const;
159 Bool_t operator<=(Element val) const;
160 Bool_t operator> (Element val) const;
161 Bool_t operator>=(Element val) const;
162
164 Bool_t SomePositive (const TVectorT<Element> &select);
165 void AddSomeConstant (Element val,const TVectorT<Element> &select);
166
167 void Randomize (Element alpha,Element beta,Double_t &seed);
168
171
172 void Add(const TVectorT<Element> &v);
173 void Add(const TVectorT<Element> &v1, const TVectorT<Element> &v2);
174 void Clear(Option_t * /*option*/ ="") { if (fIsOwner) Delete_m(fNrows,fElements);
175 else fElements = 0;
176 fNrows = 0; }
177 void Draw (Option_t *option=""); // *MENU*
178 void Print(Option_t *option="") const; // *MENU*
179
180 ClassDef(TVectorT,4) // Template of Vector class
181};
182
183#ifndef __CINT__
184// When building with -fmodules, it instantiates all pending instantiations,
185// instead of delaying them until the end of the translation unit.
186// We 'got away with' probably because the use and the definition of the
187// explicit specialization do not occur in the same TU.
188//
189// In case we are building with -fmodules, we need to forward declare the
190// specialization in order to compile the dictionary G__Matrix.cxx.
192#endif // __CINT__
193
194template<class Element> inline TVectorT<Element> &TVectorT<Element>::Use (Int_t n,Element *data) { return Use(0,n-1,data); }
195template<class Element> inline const TVectorT<Element> &TVectorT<Element>::Use (Int_t n,const Element *data) const { return Use(0,n-1,data); }
196template<class Element> inline TVectorT<Element> &TVectorT<Element>::Use (TVectorT &v)
197 {
198 R__ASSERT(v.IsValid());
199 return Use(v.GetLwb(),v.GetUpb(),v.GetMatrixArray());
200 }
201template<class Element> inline const TVectorT<Element> &TVectorT<Element>::Use (const TVectorT &v) const
202 {
203 R__ASSERT(v.IsValid());
204 return Use(v.GetLwb(),v.GetUpb(),v.GetMatrixArray());
205 }
206template<class Element> inline TVectorT<Element> TVectorT<Element>::GetSub (Int_t row_lwb,Int_t row_upb,Option_t *option) const
207 {
208 TVectorT tmp;
209 this->GetSub(row_lwb,row_upb,tmp,option);
210 return tmp;
211 }
212
213template<class Element> inline const Element &TVectorT<Element>::operator()(Int_t ind) const
214{
215 // Access a vector element.
216
217 R__ASSERT(IsValid());
218 const Int_t aind = ind-fRowLwb;
219 if (aind >= fNrows || aind < 0) {
220 Error("operator()","Request index(%d) outside vector range of %d - %d",ind,fRowLwb,fRowLwb+fNrows);
222 }
223
224 return fElements[aind];
225}
226template<class Element> inline Element &TVectorT<Element>::operator()(Int_t ind)
227{
228 // Access a vector element.
229
230 R__ASSERT(IsValid());
231 const Int_t aind = ind-fRowLwb;
232 if (aind >= fNrows || aind < 0) {
233 Error("operator()","Request index(%d) outside vector range of %d - %d",ind,fRowLwb,fRowLwb+fNrows);
235 }
236
237 return fElements[aind];
238}
239inline namespace TMatrixTAutoloadOps {
240
241template<class Element> Bool_t operator== (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
242template<class Element> TVectorT<Element> operator+ (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
243template<class Element> TVectorT<Element> operator- (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
244template<class Element> Element operator* (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
245template<class Element> TVectorT<Element> operator* (const TMatrixT <Element> &a, const TVectorT <Element> &source);
246template<class Element> TVectorT<Element> operator* (const TMatrixTSym <Element> &a, const TVectorT <Element> &source);
247template<class Element> TVectorT<Element> operator* (const TMatrixTSparse<Element> &a, const TVectorT <Element> &source);
248template<class Element> TVectorT<Element> operator* ( Element val, const TVectorT <Element> &source);
249template<class Element>
250inline
251TVectorT<Element> operator* (const TVectorT <Element> &source, Element val) { return val * source; }
252
253template<class Element> Element Dot (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
254template <class Element1,class Element2>
256template <class Element1,class Element2,class Element3>
258template <class Element1,class Element2,class Element3>
259 Element1 Mult (const TVectorT <Element1> &v1, const TMatrixT <Element2> &m, const TVectorT <Element3> &v2);
260
261template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source);
262template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixT <Element> &a,
263 const TVectorT<Element> &source);
264template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSym <Element> &a,
265 const TVectorT<Element> &source);
266template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSparse<Element> &a,
267 const TVectorT<Element> &source);
268template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
269 const TVectorT <Element> &source2);
270template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
271 const TVectorT <Element> &source2,const TVectorT <Element> &select);
272template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
273 const TVectorT <Element> &source2);
274template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
275 const TVectorT <Element> &source2,const TVectorT <Element> &select);
276template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source);
277template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
278template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source);
279template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
280
281template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2,Int_t verbose=0);
282// Check matrix and vector for compatibility in multiply: M * v and v * M
283template<class Element1,class Element2> Bool_t AreCompatible(const TMatrixT<Element1> &m, const TVectorT<Element2> &v, Int_t verbose=0);
284template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v, const TMatrixT<Element2> &m, Int_t verbose=0);
285
286template<class Element> void Compare (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
287template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose, Element maxDevAllow);
288template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose)
289 { return VerifyVectorValue(m,val,verbose,Element(0.0)); }
290template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val)
291 { return VerifyVectorValue(m,val,1,Element(0.0)); }
292template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2, Int_t verbose, Element maxDevAllow);
294 { return VerifyVectorIdentity(m1,m2,verbose,Element(0.0)); }
295template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2)
296 { return VerifyVectorIdentity(m1,m2,1,Element(0.0)); }
297} // inline namespace TMatrixTAutoloadOps
298#endif
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
int Int_t
Definition: RtypesCore.h:45
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
#define BIT(n)
Definition: Rtypes.h:85
#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
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
static Element & NaNValue()
TMatrixTSparse.
TMatrixTSym.
Definition: TMatrixTSym.h:34
TMatrixT.
Definition: TMatrixT.h:39
Mother of all ROOT objects.
Definition: TObject.h:37
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:283
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
void ResetBit(UInt_t f)
Definition: TObject.h:186
TVectorT.
Definition: TVectorT.h:27
TVectorT< Element > & Zero()
Set vector elements to zero.
Definition: TVectorT.cxx:453
Bool_t operator>=(Element val) const
Are all vector elements >= val?
Definition: TVectorT.cxx:1221
Element * New_m(Int_t size)
default kTRUE, when Use array kFALSE
Definition: TVectorT.cxx:67
void MakeValid()
Definition: TVectorT.h:82
TVectorT< Element > & Apply(const TElementActionT< Element > &action)
Apply action to each element of the vector.
Definition: TVectorT.cxx:1322
void SetElements(const Element *elements)
Definition: TVectorT.h:85
void Allocate(Int_t nrows, Int_t row_lwb=0, Int_t init=0)
Allocate new vector.
Definition: TVectorT.cxx:151
TVectorT< Element > & Sqr()
Square each element of the vector.
Definition: TVectorT.cxx:482
Element & operator[](Int_t index)
Definition: TVectorT.h:122
Int_t fNrows
Definition: TVectorT.h:30
Element Min() const
return minimum vector element value
Definition: TVectorT.cxx:654
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: TVectorT.cxx:124
void Clear(Option_t *="")
Definition: TVectorT.h:174
Element & operator()(Int_t index)
Definition: TVectorT.h:226
TVectorT< Element > & Use(TVectorT< Element > &v)
Definition: TVectorT.h:196
Element Norm1() const
Compute the 1-norm of the vector SUM{ |v[i]| }.
Definition: TVectorT.cxx:567
void Delete_m(Int_t size, Element *&)
Delete data pointer m, if it was assigned on the heap.
Definition: TVectorT.cxx:53
TVectorT(const TVectorT< Element2 > &another)
Definition: TVectorT.h:62
Element NormInf() const
Compute the infinity-norm of the vector MAX{ |v[i]| }.
Definition: TVectorT.cxx:603
Element Sum() const
Compute sum of elements.
Definition: TVectorT.cxx:637
void AddSomeConstant(Element val, const TVectorT< Element > &select)
Add to vector elements as selected through array select the value val.
Definition: TVectorT.cxx:1284
Bool_t operator!=(Element val) const
Are all vector elements not equal to val?
Definition: TVectorT.cxx:1153
void Invalidate()
Definition: TVectorT.h:81
Int_t fRowLwb
Definition: TVectorT.h:31
Bool_t IsOwner() const
Definition: TVectorT.h:84
Bool_t MatchesNonZeroPattern(const TVectorT< Element > &select)
Check if vector elements as selected through array select are non-zero.
Definition: TVectorT.cxx:1238
TVectorT< Element > & GetSub(Int_t row_lwb, Int_t row_upb, TVectorT< Element > &target, Option_t *option="S") const
Get subvector [row_lwb..row_upb]; The indexing range of the returned vector depends on the argument o...
Definition: TVectorT.cxx:373
TVectorT< Element > & Shift(Int_t row_shift)
Definition: TVectorT.h:87
TVectorT< Element > & Abs()
Take an absolute value of a vector, i.e. apply Abs() to each element.
Definition: TVectorT.cxx:464
Bool_t operator==(Element val) const
Are all vector elements equal to val?
Definition: TVectorT.cxx:1136
Bool_t operator>(Element val) const
Are all vector elements > val?
Definition: TVectorT.cxx:1204
TVectorT< Element > & ResizeTo(Int_t n)
Definition: TVectorT.h:89
TVectorT< Element > & ResizeTo(Int_t lwb, Int_t upb)
Resize the vector to [lwb:upb] .
Definition: TVectorT.cxx:294
void Draw(Option_t *option="")
Draw this vector The histogram is named "TVectorT" by default and no title.
Definition: TVectorT.cxx:1353
TVectorT< Element > & operator=(const TVectorT< Element > &source)
Notice that this assignment does NOT change the ownership : if the storage space was adopted,...
Definition: TVectorT.cxx:680
Int_t GetNrows() const
Definition: TVectorT.h:75
Int_t GetUpb() const
Definition: TVectorT.h:74
TVectorT< Element > & SetSub(Int_t row_lwb, const TVectorT< Element > &source)
Insert vector source starting at [row_lwb], thereby overwriting the part [row_lwb....
Definition: TVectorT.cxx:422
TClass * Class()
void Randomize(Element alpha, Element beta, Double_t &seed)
randomize vector elements value
Definition: TVectorT.cxx:1305
TVectorT< Element > & Use(Int_t n, Element *data)
Definition: TVectorT.h:194
Bool_t IsValid() const
Definition: TVectorT.h:83
void Add(const TVectorT< Element > &v)
Add vector v to this vector.
Definition: TVectorT.cxx:84
const Element & operator()(Int_t index) const
Definition: TVectorT.h:213
TVectorT< Element > & operator+=(Element val)
Add val to every element of the vector.
Definition: TVectorT.cxx:863
TVectorT< Element > & Use(Int_t lwb, Int_t upb, Element *data)
Use the array data to fill the vector lwb..upb].
Definition: TVectorT.cxx:349
const TVectorT< Element > & Use(Int_t lwb, Int_t upb, const Element *data) const
Definition: TVectorT.h:93
TVectorT< Element > & SelectNonZeros(const TVectorT< Element > &select)
Keep only element as selected through array select non-zero.
Definition: TVectorT.cxx:544
Element Max() const
return maximum vector element value
Definition: TVectorT.cxx:666
@ kWorkMax
Definition: TVectorT.h:35
Bool_t operator<(Element val) const
Are all vector elements < val?
Definition: TVectorT.cxx:1170
Bool_t operator<=(Element val) const
Are all vector elements <= val?
Definition: TVectorT.cxx:1187
TVectorT< Element > & operator*=(Element val)
Multiply every element of the vector with val.
Definition: TVectorT.cxx:895
void Print(Option_t *option="") const
Print the vector as a list of elements.
Definition: TVectorT.cxx:1363
const TVectorT< Element > & Use(const TVectorT< Element > &v) const
Definition: TVectorT.h:201
Bool_t SomePositive(const TVectorT< Element > &select)
Check if vector elements as selected through array select are all positive.
Definition: TVectorT.cxx:1261
Element * fElements
Definition: TVectorT.h:32
const Element & operator[](Int_t index) const
Definition: TVectorT.h:121
Int_t NonZeros() const
Compute the number of elements != 0.0.
Definition: TVectorT.cxx:620
Bool_t fIsOwner
data container
Definition: TVectorT.h:38
TVectorT< Element > & ResizeTo(const TVectorT< Element > &v)
Definition: TVectorT.h:90
Int_t GetLwb() const
Definition: TVectorT.h:73
EVectorStatusBits
Definition: TVectorT.h:47
@ kStatus
Definition: TVectorT.h:48
const TVectorT< Element > & Use(Int_t n, const Element *data) const
Definition: TVectorT.h:195
TVectorT< Element > & Invert()
v[i] = 1/v[i]
Definition: TVectorT.cxx:522
TVectorT()
Definition: TVectorT.h:53
Int_t GetNoElements() const
Definition: TVectorT.h:76
@ kSizeMax
Definition: TVectorT.h:34
Element Norm2Sqr() const
Compute the square of the 2-norm SUM{ v[i]^2 }.
Definition: TVectorT.cxx:584
Element * GetMatrixArray()
Definition: TVectorT.h:78
virtual ~TVectorT()
Definition: TVectorT.h:71
const Element * GetMatrixArray() const
Definition: TVectorT.h:79
TVectorT< Element > & operator-=(Element val)
Subtract val from every element of the vector.
Definition: TVectorT.cxx:879
Element fDataStack[kSizeMax]
Definition: TVectorT.h:37
TVectorT< Element > GetSub(Int_t row_lwb, Int_t row_upb, Option_t *option="S") const
Definition: TVectorT.h:206
TVectorT< Element > & Sqrt()
Take square root of all elements.
Definition: TVectorT.cxx:500
TPaveText * pt
double beta(double x, double y)
Calculates the beta function.
const Int_t n
Definition: legend1.C:16
static constexpr double ps
static constexpr double m2
Bool_t VerifyVectorValue(const TVectorT< Element > &m, Element val, Int_t verbose, Element maxDevAllow)
Validate that all elements of vector have value val within maxDevAllow .
Definition: TVectorT.cxx:2262
TVectorT< Element > & AddElemDiv(TVectorT< Element > &target, Element scalar, const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Modify addition: target += scalar * ElementDiv(source1,source2) .
Definition: TVectorT.cxx:1917
TMatrixT< Element > operator+(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1+source2
Definition: TMatrixT.cxx:2322
Bool_t AreCompatible(const TVectorT< Element1 > &v, const TMatrixT< Element2 > &m, Int_t verbose=0)
Check if m and v are both valid and have compatible shapes for v * M.
Definition: TVectorT.cxx:2183
void Compare(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2)
Compare two matrices and print out the result of the comparison.
TMatrixT< Element > & ElementMult(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Multiply target by the source, element-by-element.
Definition: TMatrixT.cxx:2982
TVectorT< Element > & AddElemMult(TVectorT< Element > &target, Element scalar, const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Modify addition: target += scalar * ElementMult(source1,source2) .
Definition: TVectorT.cxx:1844
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.
Definition: TMatrixT.cxx:2934
TMatrixT< Element1 > OuterProduct(const TVectorT< Element1 > &v1, const TVectorT< Element2 > &v2)
Return the matrix M = v1 * v2'.
Definition: TVectorT.cxx:1495
Element Dot(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
return inner-produvt v1 . v2
Definition: TVectorT.cxx:1478
Bool_t VerifyVectorIdentity(const TVectorT< Element > &m1, const TVectorT< Element > &m2, Int_t verbose, Element maxDevAllow)
Verify that elements of the two vectors are equal within maxDevAllow .
Definition: TVectorT.cxx:2297
TMatrixT< Element > & ElementDiv(TMatrixT< Element > &target, const TMatrixT< Element > &source)
Divide target by the source, element-by-element.
Definition: TMatrixT.cxx:3022
Element1 Mult(const TVectorT< Element1 > &v1, const TMatrixT< Element2 > &m, const TVectorT< Element3 > &v2)
Perform v1 * M * v2, a scalar result.
Definition: TVectorT.cxx:1542
TMatrixT< Element > operator-(const TMatrixT< Element > &source1, const TMatrixT< Element > &source2)
operation this = source1-source2
Definition: TMatrixT.cxx:2373
Bool_t operator==(const TMatrixTBase< Element > &m1, const TMatrixTBase< Element > &m2)
Check to see if two matrices are identical.
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 .
auto * m
Definition: textangle.C:8
auto * a
Definition: textangle.C:12