Logo ROOT   6.21/01
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 
27 template<class Element> class TVectorT : public TObject {
28 
29 protected:
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 
47  enum EVectorStatusBits {
48  kStatus = BIT(14) // set if vector object is valid
49  };
50 
51 public:
52 
53  TVectorT() : fNrows(0), fRowLwb(0), fElements(0), fDataStack (), fIsOwner(kTRUE) { }
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);
59  TVectorT(const TMatrixTRow_const <Element> &mr);
60  TVectorT(const TMatrixTColumn_const<Element> &mc);
61  TVectorT(const TMatrixTDiag_const <Element> &md);
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; }
88  TVectorT<Element> &ResizeTo (Int_t lwb,Int_t upb);
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 ;
97  TVectorT<Element> &Use (TVectorT<Element> &v);
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 
104  TVectorT<Element> &Zero();
105  TVectorT<Element> &Abs ();
106  TVectorT<Element> &Sqr ();
107  TVectorT<Element> &Sqrt();
108  TVectorT<Element> &Invert();
109  TVectorT<Element> &SelectNonZeros(const TVectorT<Element> &select);
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 
124  TVectorT<Element> &operator= (const TVectorT <Element> &source);
125  TVectorT<Element> &operator= (const TMatrixTRow_const <Element> &mr);
126  TVectorT<Element> &operator= (const TMatrixTColumn_const <Element> &mc);
127  TVectorT<Element> &operator= (const TMatrixTDiag_const <Element> &md);
128  TVectorT<Element> &operator= (const TMatrixTSparseRow_const <Element> &md);
129  TVectorT<Element> &operator= (const TMatrixTSparseDiag_const<Element> &md);
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 
150  TVectorT<Element> &operator+=(const TVectorT <Element> &source);
151  TVectorT<Element> &operator-=(const TVectorT <Element> &source);
152  TVectorT<Element> &operator*=(const TMatrixT <Element> &a);
153  TVectorT<Element> &operator*=(const TMatrixTSym <Element> &a);
154  TVectorT<Element> &operator*=(const TMatrixTSparse<Element> &a);
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 
163  Bool_t MatchesNonZeroPattern(const TVectorT<Element> &select);
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 
169  TVectorT<Element> &Apply(const TElementActionT <Element> &action);
170  TVectorT<Element> &Apply(const TElementPosActionT<Element> &action);
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.
191 template <> TClass *TVectorT<double>::Class();
192 #endif // __CINT__
193 
194 template<class Element> inline TVectorT<Element> &TVectorT<Element>::Use (Int_t n,Element *data) { return Use(0,n-1,data); }
195 template<class Element> inline const TVectorT<Element> &TVectorT<Element>::Use (Int_t n,const Element *data) const { return Use(0,n-1,data); }
196 template<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  }
201 template<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  }
206 template<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 
213 template<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);
221  return TMatrixTBase<Element>::NaNValue();
222  }
223 
224  return fElements[aind];
225 }
226 template<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);
234  return TMatrixTBase<Element>::NaNValue();
235  }
236 
237  return fElements[aind];
238 }
239 
240 template<class Element> Bool_t operator== (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
241 template<class Element> TVectorT<Element> operator+ (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
242 template<class Element> TVectorT<Element> operator- (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
243 template<class Element> Element operator* (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
244 template<class Element> TVectorT<Element> operator* (const TMatrixT <Element> &a, const TVectorT <Element> &source);
245 template<class Element> TVectorT<Element> operator* (const TMatrixTSym <Element> &a, const TVectorT <Element> &source);
246 template<class Element> TVectorT<Element> operator* (const TMatrixTSparse<Element> &a, const TVectorT <Element> &source);
247 template<class Element> TVectorT<Element> operator* ( Element val, const TVectorT <Element> &source);
248 template<class Element>
249 inline
250 TVectorT<Element> operator* (const TVectorT <Element> &source, Element val) { return val * source; }
251 
252 template<class Element> Element Dot (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
253 template <class Element1,class Element2>
254  TMatrixT<Element1> OuterProduct(const TVectorT <Element1> &v1, const TVectorT <Element2> &v2);
255 template <class Element1,class Element2,class Element3>
256  TMatrixT<Element1> &OuterProduct( TMatrixT <Element1> &target, const TVectorT <Element2> &v1, const TVectorT <Element3> &v2);
257 template <class Element1,class Element2,class Element3>
258  Element1 Mult (const TVectorT <Element1> &v1, const TMatrixT <Element2> &m, const TVectorT <Element3> &v2);
259 
260 template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source);
261 template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixT <Element> &a,
262  const TVectorT<Element> &source);
263 template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSym <Element> &a,
264  const TVectorT<Element> &source);
265 template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSparse<Element> &a,
266  const TVectorT<Element> &source);
267 template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
268  const TVectorT <Element> &source2);
269 template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
270  const TVectorT <Element> &source2,const TVectorT <Element> &select);
271 template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
272  const TVectorT <Element> &source2);
273 template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
274  const TVectorT <Element> &source2,const TVectorT <Element> &select);
275 template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source);
276 template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
277 template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source);
278 template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
279 
280 template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2,Int_t verbose=0);
281 // Check matrix and vector for compatibility in multiply: M * v and v * M
282 template<class Element1,class Element2> Bool_t AreCompatible(const TMatrixT<Element1> &m, const TVectorT<Element2> &v, Int_t verbose=0);
283 template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v, const TMatrixT<Element2> &m, Int_t verbose=0);
284 
285 template<class Element> void Compare (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
286 template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose, Element maxDevAllow);
287 template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose)
288  { return VerifyVectorValue(m,val,verbose,Element(0.0)); }
289 template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val)
290  { return VerifyVectorValue(m,val,1,Element(0.0)); }
291 template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2, Int_t verbose, Element maxDevAllow);
292 template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2, Int_t verbose)
293  { return VerifyVectorIdentity(m1,m2,verbose,Element(0.0)); }
294 template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2)
295  { return VerifyVectorIdentity(m1,m2,1,Element(0.0)); }
296 
297 #endif
TVectorT::Use
const TVectorT< Element > & Use(Int_t lwb, Int_t upb, const Element *data) const
Definition: TVectorT.h:93
TVectorT::SetElements
void SetElements(const Element *elements)
Definition: TVectorT.h:85
Compare
void Compare(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Compare two vectors and print out the result of the comparison.
Definition: TVectorT.cxx:2207
TVectorT::ResizeTo
TVectorT< Element > & ResizeTo(Int_t lwb, Int_t upb)
Resize the vector to [lwb:upb] .
Definition: TVectorT.cxx:292
m
auto * m
Definition: textangle.C:8
TVectorT::Invalidate
void Invalidate()
Definition: TVectorT.h:81
TVectorT::operator-=
TVectorT< Element > & operator-=(Element val)
Subtract val from every element of the vector.
Definition: TVectorT.cxx:877
TVectorT::GetMatrixArray
const Element * GetMatrixArray() const
Definition: TVectorT.h:79
OuterProduct
TMatrixT< Element1 > OuterProduct(const TVectorT< Element1 > &v1, const TVectorT< Element2 > &v2)
Return the matrix M = v1 * v2&#39;.
Definition: TVectorT.cxx:1493
TVectorT::operator!=
Bool_t operator!=(Element val) const
Are all vector elements not equal to val?
Definition: TVectorT.cxx:1151
TVectorT::Add
void Add(const TVectorT< Element > &v)
Add vector v to this vector.
Definition: TVectorT.cxx:82
Option_t
const char Option_t
Definition: RtypesCore.h:62
TVectorT::operator[]
const Element & operator[](Int_t index) const
Definition: TVectorT.h:121
TMatrixTColumn_const
Definition: TMatrixDUtilsfwd.h:36
TVectorT::Draw
void Draw(Option_t *option="")
Draw this vector The histogram is named "TVectorT" by default and no title.
Definition: TVectorT.cxx:1351
operator+
TVectorT< Element > operator+(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Return source1+source2.
Definition: TVectorT.cxx:1410
TVectorT::GetLwb
Int_t GetLwb() const
Definition: TVectorT.h:73
BIT
#define BIT(n)
Definition: Rtypes.h:83
TVectorT::GetUpb
Int_t GetUpb() const
Definition: TVectorT.h:74
TVectorT
TVectorT.
Definition: TMatrixTBase.h:79
TVectorT::fIsOwner
Bool_t fIsOwner
data container
Definition: TVectorT.h:38
operator*
Element operator*(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Compute the scalar product.
Definition: TVectorT.cxx:1394
R__ASSERT
#define R__ASSERT(e)
Definition: TError.h:96
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TVectorT::Invert
TVectorT< Element > & Invert()
v[i] = 1/v[i]
Definition: TVectorT.cxx:520
TGeant4Unit::ps
static constexpr double ps
Definition: TGeant4SystemOfUnits.h:165
TVectorT::GetNrows
Int_t GetNrows() const
Definition: TVectorT.h:75
v
Definition: rootcling_impl.cxx:3643
Int_t
int Int_t
Definition: RtypesCore.h:41
TVectorT::fDataStack
Element fDataStack[kSizeMax]
Definition: TVectorT.h:37
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
TVectorT::NormInf
Element NormInf() const
Compute the infinity-norm of the vector MAX{ |v[i]| }.
Definition: TVectorT.cxx:601
AreCompatible
Bool_t AreCompatible(const TVectorT< Element1 > &v1, const TVectorT< Element2 > &v2, Int_t verbose=0)
Check if v1 and v2 are both valid and have the same shape.
Definition: TVectorT.cxx:2129
AddElemDiv
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:1915
v2
Definition: rootcling_impl.cxx:3646
TVectorT::Print
void Print(Option_t *option="") const
Print the vector as a list of elements.
Definition: TVectorT.cxx:1361
TVectorT::Sqr
TVectorT< Element > & Sqr()
Square each element of the vector.
Definition: TVectorT.cxx:480
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
ROOT::Math::beta
double beta(double x, double y)
Calculates the beta function.
Definition: SpecFuncMathCore.cxx:111
TVectorT::~TVectorT
virtual ~TVectorT()
Definition: TVectorT.h:71
TVectorT::Randomize
void Randomize(Element alpha, Element beta, Double_t &seed)
randomize vector elements value
Definition: TVectorT.cxx:1303
TMatrixT
TMatrixT.
Definition: TMatrixDfwd.h:22
TVectorT::Use
TVectorT< Element > & Use(Int_t lwb, Int_t upb, Element *data)
Use the array data to fill the vector lwb..upb].
Definition: TVectorT.cxx:347
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:326
ElementDiv
TVectorT< Element > & ElementDiv(TVectorT< Element > &target, const TVectorT< Element > &source)
Divide target by the source, element-by-element.
Definition: TVectorT.cxx:2073
TVectorT::operator>=
Bool_t operator>=(Element val) const
Are all vector elements >= val?
Definition: TVectorT.cxx:1219
TVectorT::SetSub
TVectorT< Element > & SetSub(Int_t row_lwb, const TVectorT< Element > &source)
Insert vector source starting at [row_lwb], thereby overwriting the part [row_lwb..row_lwb+nrows_source];.
Definition: TVectorT.cxx:420
TMatrixTSparseRow_const
Definition: TMatrixDUtilsfwd.h:40
TObject::operator=
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:268
Mult
Element1 Mult(const TVectorT< Element1 > &v1, const TMatrixT< Element2 > &m, const TVectorT< Element3 > &v2)
Perform v1 * M * v2, a scalar result.
Definition: TVectorT.cxx:1540
TVectorT::Delete_m
void Delete_m(Int_t size, Element *&)
Delete data pointer m, if it was assigned on the heap.
Definition: TVectorT.cxx:51
TMatrixTSym
TMatrixTSym.
Definition: TMatrixDSymfwd.h:22
TVectorT::Clear
void Clear(Option_t *="")
Definition: TVectorT.h:174
TVectorT::Sqrt
TVectorT< Element > & Sqrt()
Take square root of all elements.
Definition: TVectorT.cxx:498
Error
void Error(const char *location, const char *msgfmt,...)
TVectorT::Allocate
void Allocate(Int_t nrows, Int_t row_lwb=0, Int_t init=0)
Allocate new vector.
Definition: TVectorT.cxx:149
TVectorT::Shift
TVectorT< Element > & Shift(Int_t row_shift)
Definition: TVectorT.h:87
TVectorT::GetSub
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:371
TVectorT::Sum
Element Sum() const
Compute sum of elements.
Definition: TVectorT.cxx:635
TVectorT::Min
Element Min() const
return minimum vector element value
Definition: TVectorT.cxx:652
TVectorT::GetMatrixArray
Element * GetMatrixArray()
Definition: TVectorT.h:78
operator==
Bool_t operator==(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Check to see if two vectors are identical.
Definition: TVectorT.cxx:1384
TGeant4Unit::m2
static constexpr double m2
Definition: TGeant4SystemOfUnits.h:123
pt
TPaveText * pt
Definition: entrylist_figure1.C:7
TVectorT::operator==
Bool_t operator==(Element val) const
Are all vector elements equal to val?
Definition: TVectorT.cxx:1134
TMatrixTSparse
TMatrixTSparse.
Definition: TMatrixDSparsefwd.h:22
a
auto * a
Definition: textangle.C:12
TVectorT::Class
TClass * Class()
TVectorT::operator=
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:678
TVectorT::operator*=
TVectorT< Element > & operator*=(Element val)
Multiply every element of the vector with val.
Definition: TVectorT.cxx:893
TVectorT::Zero
TVectorT< Element > & Zero()
Set vector elements to zero.
Definition: TVectorT.cxx:451
TVectorT::IsValid
Bool_t IsValid() const
Definition: TVectorT.h:83
BatchHelpers::init
EvaluateInfo init(std::vector< RooRealProxy > parameters, std::vector< ArrayWrapper * > wrappers, std::vector< double *> arrays, size_t begin, size_t batchSize)
ElementMult
TVectorT< Element > & ElementMult(TVectorT< Element > &target, const TVectorT< Element > &source)
Multiply target by the source, element-by-element.
Definition: TVectorT.cxx:2030
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
TVectorT::operator>
Bool_t operator>(Element val) const
Are all vector elements > val?
Definition: TVectorT.cxx:1202
TMatrixTDiag_const
Definition: TMatrixDUtilsfwd.h:37
TVectorT::GetNoElements
Int_t GetNoElements() const
Definition: TVectorT.h:76
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75
TVectorT::MakeValid
void MakeValid()
Definition: TVectorT.h:82
TVectorT::Norm2Sqr
Element Norm2Sqr() const
Compute the square of the 2-norm SUM{ v[i]^2 }.
Definition: TVectorT.cxx:582
TVectorT::operator<=
Bool_t operator<=(Element val) const
Are all vector elements <= val?
Definition: TVectorT.cxx:1185
TVectorT::Norm1
Element Norm1() const
Compute the 1-norm of the vector SUM{ |v[i]| }.
Definition: TVectorT.cxx:565
TVectorT::IsOwner
Bool_t IsOwner() const
Definition: TVectorT.h:84
TVectorT::TVectorT
TVectorT()
Definition: TVectorT.h:53
TVectorT::NonZeros
Int_t NonZeros() const
Compute the number of elements != 0.0.
Definition: TVectorT.cxx:618
TVectorT::SelectNonZeros
TVectorT< Element > & SelectNonZeros(const TVectorT< Element > &select)
Keep only element as selected through array select non-zero.
Definition: TVectorT.cxx:542
Double_t
double Double_t
Definition: RtypesCore.h:55
Dot
Element Dot(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
return inner-produvt v1 . v2
Definition: TVectorT.cxx:1476
TVectorT::ResizeTo
TVectorT< Element > & ResizeTo(const TVectorT< Element > &v)
Definition: TVectorT.h:90
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TVectorT::fRowLwb
Int_t fRowLwb
Definition: TVectorT.h:31
TVectorT::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: TVectorT.cxx:122
Add
TVectorT< Element > & Add(TVectorT< Element > &target, Element scalar, const TVectorT< Element > &source)
Modify addition: target += scalar * source.
Definition: TVectorT.cxx:1585
AddElemMult
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:1842
TVectorT::fNrows
Int_t fNrows
Definition: TVectorT.h:30
TVectorT::Abs
TVectorT< Element > & Abs()
Take an absolute value of a vector, i.e. apply Abs() to each element.
Definition: TVectorT.cxx:462
TVectorT::operator[]
Element & operator[](Int_t index)
Definition: TVectorT.h:122
TVectorT::fElements
Element * fElements
Definition: TVectorT.h:32
TVectorT::MatchesNonZeroPattern
Bool_t MatchesNonZeroPattern(const TVectorT< Element > &select)
Check if vector elements as selected through array select are non-zero.
Definition: TVectorT.cxx:1236
TMatrixTBase::NaNValue
static Element & NaNValue()
Definition: TMatrixTBase.cxx:1282
VerifyVectorIdentity
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:2295
TVectorT::ResizeTo
TVectorT< Element > & ResizeTo(Int_t n)
Definition: TVectorT.h:89
TObject::ResetBit
void ResetBit(UInt_t f)
Definition: TObject.h:171
TMatrixTRow_const
Definition: TMatrixDUtilsfwd.h:35
TMatrixTSparseDiag_const
Definition: TMatrixDUtilsfwd.h:41
VerifyVectorValue
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:2260
operator-
TVectorT< Element > operator-(const TVectorT< Element > &source1, const TVectorT< Element > &source2)
Return source1-source2.
Definition: TVectorT.cxx:1421
TVectorT::Max
Element Max() const
return maximum vector element value
Definition: TVectorT.cxx:664
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:87
TVectorT::New_m
Element * New_m(Int_t size)
default kTRUE, when Use array kFALSE
Definition: TVectorT.cxx:65
TVectorT::AddSomeConstant
void AddSomeConstant(Element val, const TVectorT< Element > &select)
Add to vector elements as selected through array select the value val.
Definition: TVectorT.cxx:1282
n
const Int_t n
Definition: legend1.C:16
TVectorT::SomePositive
Bool_t SomePositive(const TVectorT< Element > &select)
Check if vector elements as selected through array select are all positive.
Definition: TVectorT.cxx:1259
v1
Definition: rootcling_impl.cxx:3645
TVectorT::TVectorT
TVectorT(const TVectorT< Element2 > &another)
Definition: TVectorT.h:62
TVectorT::operator<
Bool_t operator<(Element val) const
Are all vector elements < val?
Definition: TVectorT.cxx:1168
TVectorT::operator+=
TVectorT< Element > & operator+=(Element val)
Add val to every element of the vector.
Definition: TVectorT.cxx:861
TVectorT::Apply
TVectorT< Element > & Apply(const TElementActionT< Element > &action)
Apply action to each element of the vector.
Definition: TVectorT.cxx:1320
TVectorT::operator()
const Element & operator()(Int_t index) const
Definition: TVectorT.h:213