Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TMatrixTSparse.h
Go to the documentation of this file.
1// @(#)root/matrix:$Id$
2// Authors: Fons Rademakers, Eddy Offermann Feb 2004
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_TMatrixTSparse
13#define ROOT_TMatrixTSparse
14
15#include "TMatrixTBase.h"
16#include "TMatrixTUtils.h"
17
18#include <cstring>
19
20#ifdef CBLAS
21#include <vecLib/vBLAS.h>
22//#include <cblas.h>
23#endif
24
25//////////////////////////////////////////////////////////////////////////
26// //
27// TMatrixTSparse //
28// //
29// Template class of a general sparse matrix in the Harwell-Boeing //
30// format //
31// //
32//////////////////////////////////////////////////////////////////////////
33
34template<class Element> class TMatrixT;
35
36template<class Element> class TMatrixTSparse : public TMatrixTBase<Element> {
37
38protected:
39
40 Int_t *fRowIndex; //[fNrowIndex] row index
41 Int_t *fColIndex; //[fNelems] column index
42 Element *fElements; //[fNelems]
43
44 void Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,
45 Int_t init = 0,Int_t nr_nonzeros = 0);
46
47 // Elementary constructors
50 void AMultB (const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0) {
51 const TMatrixTSparse<Element> bsp = b;
53 void AMultB (const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) {
55
57 void AMultBt(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
58 void AMultBt(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
59
60 void APlusB (const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
61 void APlusB (const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
62 void APlusB (const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0) { APlusB(b,a,constr); }
63
65 void AMinusB(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr=0);
66 void AMinusB(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr=0);
67
68public:
69
72
73 TMatrixTSparse() { fElements = nullptr; fRowIndex = nullptr; fColIndex = nullptr; }
74 TMatrixTSparse(Int_t nrows,Int_t ncols);
75 TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
76 TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
77 Int_t *row, Int_t *col,Element *data);
79 TMatrixTSparse(const TMatrixT<Element> &another);
80
83 TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixT <Element> &b);
84 TMatrixTSparse(const TMatrixT <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSparse<Element> &b);
85
87
88 const Element *GetMatrixArray () const override;
89 Element *GetMatrixArray () override;
90 const Int_t *GetRowIndexArray() const override;
92 const Int_t *GetColIndexArray() const override;
94
95 TMatrixTBase<Element> &SetRowIndexArray(Int_t *data) override { memmove(fRowIndex,data,(this->fNrows+1)*sizeof(Int_t)); return *this; }
96 TMatrixTBase<Element> &SetColIndexArray(Int_t *data) override { memmove(fColIndex,data,this->fNelems*sizeof(Int_t)); return *this; }
97
101 TMatrixTSparse<Element> &SetSparseIndexAB(const TMatrixT <Element> &a,const TMatrixTSparse<Element> &b);
103 { return SetSparseIndexAB(b,a); }
104
105 void GetMatrix2Array (Element *data,Option_t * /*option*/ ="") const override;
106 TMatrixTBase<Element> &SetMatrixArray (const Element *data,Option_t * /*option*/="") override
107 { memcpy(fElements,data,this->fNelems*sizeof(Element)); return *this; }
108 virtual TMatrixTBase<Element> &SetMatrixArray (Int_t nr_nonzeros,Int_t *irow,Int_t *icol,Element *data);
109 virtual TMatrixTBase<Element> &
110 SetMatrixArray(Int_t nr_nonzeros, Int_t nrows, Int_t ncols, Int_t *irow, Int_t *icol, Element *data);
111 TMatrixTBase<Element> &InsertRow (Int_t row,Int_t col,const Element *v,Int_t n=-1) override;
112 void ExtractRow (Int_t row,Int_t col, Element *v,Int_t n=-1) const override;
113
114 TMatrixTBase<Element> &ResizeTo(Int_t nrows,Int_t ncols,Int_t nr_nonzeros=-1) override;
115 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;
116 inline TMatrixTBase<Element> &ResizeTo(const TMatrixTSparse<Element> &m) {return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),
117 m.GetColUpb(),m.GetNoElements()); }
118
119 void Clear(Option_t * /*option*/ ="") override { if (this->fIsOwner) {
120 if (fElements) { delete [] fElements; fElements = nullptr; }
121 if (fRowIndex) { delete [] fRowIndex; fRowIndex = nullptr; }
122 if (fColIndex) { delete [] fColIndex; fColIndex = nullptr; }
123 }
124 this->fNelems = 0;
125 this->fNrowIndex = 0;
126 }
127
128 TMatrixTSparse<Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
129 Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
130 const TMatrixTSparse<Element> &Use (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t nr_nonzeros,
131 const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
132 { return (const TMatrixTSparse<Element>&)
133 ((const_cast<TMatrixTSparse<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb,nr_nonzeros,
134 const_cast<Int_t *>(pRowIndex),
135 const_cast<Int_t *>(pColIndex),
136 const_cast<Element *>(pData))); }
137 TMatrixTSparse<Element> &Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
138 Int_t *pRowIndex,Int_t *pColIndex,Element *pData);
139 const TMatrixTSparse<Element> &Use (Int_t nrows,Int_t ncols,Int_t nr_nonzeros,
140 const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const;
143
144 TMatrixTBase<Element> &GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
145 TMatrixTBase<Element> &target,Option_t *option="S") const override;
146 TMatrixTSparse<Element> GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
147 TMatrixTBase<Element> &SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source) override;
148
149 Bool_t IsSymmetric() const override { return (*this == TMatrixTSparse<Element>(kTransposed,*this)); }
151 inline TMatrixTSparse<Element> &T () { return this->Transpose(*this); }
152
153 inline void Mult(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b) { AMultB(a,b,0); }
154
155 TMatrixTBase<Element> &Zero () override;
157
158 Element RowNorm () const override;
159 Element ColNorm () const override;
160 Int_t NonZeros() const override { return this->fNelems; }
161
162 TMatrixTBase<Element> &NormByDiag(const TVectorT<Element> &/*v*/,Option_t * /*option*/) override
163 { MayNotUse("NormByDiag"); return *this; }
164
165 // Either access a_ij as a(i,j)
166 Element operator()(Int_t rown,Int_t coln) const override;
167 Element &operator()(Int_t rown,Int_t coln) override;
168
169 // or as a[i][j]
171 inline TMatrixTSparseRow <Element> operator[](Int_t rown) { return TMatrixTSparseRow <Element>(*this,rown); }
172
175
180
182 if (this == &source) APlusB (tmp,tmp,1);
183 else APlusB (tmp,source,1);
184 return *this; }
186 APlusB(tmp,source,1); return *this; }
188 if (this == &source) AMinusB (tmp,tmp,1);
189 else AMinusB(tmp,source,1);
190 return *this; }
192 AMinusB(tmp,source,1); return *this; }
194 if (this == &source) AMultB (tmp,tmp,1);
195 else AMultB (tmp,source,1);
196 return *this; }
198 AMultB(tmp,source,1);
199 return *this; }
200
201 TMatrixTBase <Element> &Randomize (Element alpha,Element beta,Double_t &seed) override;
202 virtual TMatrixTSparse<Element> &RandomizePD(Element alpha,Element beta,Double_t &seed);
203
204 ClassDefOverride(TMatrixTSparse,3) // Template of Sparse Matrix class
205};
206
207#ifndef __CINT__
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 // __CINT__
217
218template <class Element> inline const Element *TMatrixTSparse<Element>::GetMatrixArray () const { return fElements; }
219template <class Element> inline Element *TMatrixTSparse<Element>::GetMatrixArray () { return fElements; }
220template <class Element> inline const Int_t *TMatrixTSparse<Element>::GetRowIndexArray() const { return fRowIndex; }
221template <class Element> inline Int_t *TMatrixTSparse<Element>::GetRowIndexArray() { return fRowIndex; }
222template <class Element> inline const Int_t *TMatrixTSparse<Element>::GetColIndexArray() const { return fColIndex; }
223template <class Element> inline Int_t *TMatrixTSparse<Element>::GetColIndexArray() { return fColIndex; }
224
225template <class Element>
227 Int_t *pRowIndex,Int_t *pColIndex,Element *pData)
228 { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
229template <class Element>
231 const Int_t *pRowIndex,const Int_t *pColIndex,const Element *pData) const
232 { return Use(0,nrows-1,0,ncols-1,nr_nonzeros,pRowIndex,pColIndex,pData); }
233template <class Element>
235 { R__ASSERT(a.IsValid());
236 return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
237 a.GetNoElements(),a.GetRowIndexArray(),
238 a.GetColIndexArray(),a.GetMatrixArray()); }
239template <class Element>
241 { R__ASSERT(a.IsValid());
242 return Use(a.GetRowLwb(),a.GetRowUpb(),a.GetColLwb(),a.GetColUpb(),
243 a.GetNoElements(),a.GetRowIndexArray(),
244 a.GetColIndexArray(),a.GetMatrixArray()); }
245
246template <class Element>
248 Option_t *option) const
249 {
251 this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
252 return tmp;
253 }
254
255template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
256template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
257template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
258template <class Element> TMatrixTSparse<Element> operator+ (const TMatrixTSparse<Element> &source , Element val );
259template <class Element> TMatrixTSparse<Element> operator+ ( Element val ,const TMatrixTSparse<Element> &source );
260template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
261template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
262template <class Element> TMatrixTSparse<Element> operator- (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
263template <class Element> TMatrixTSparse<Element> operator- (const TMatrixTSparse<Element> &source , Element val );
264template <class Element> TMatrixTSparse<Element> operator- ( Element val ,const TMatrixTSparse<Element> &source );
265template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2);
266template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2);
267template <class Element> TMatrixTSparse<Element> operator* (const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2);
268template <class Element> TMatrixTSparse<Element> operator* ( Element val ,const TMatrixTSparse<Element> &source );
269template <class Element> TMatrixTSparse<Element> operator* (const TMatrixTSparse<Element> &source, Element val );
270
271template <class Element> TMatrixTSparse<Element> &Add (TMatrixTSparse<Element> &target, Element scalar,
272 const TMatrixTSparse<Element> &source);
275
276template <class Element> Bool_t AreCompatible(const TMatrixTSparse<Element> &m1,const TMatrixTSparse<Element> &m2,Int_t verbose=0);
277
278#endif
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
bool Bool_t
Definition RtypesCore.h:63
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:341
#define R__ASSERT(e)
Definition TError.h:118
Option_t Option_t option
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
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
TMatrixTSparse< Element > & ElementDiv(TMatrixTSparse< Element > &target, const TMatrixTSparse< Element > &source)
Divide target by the source, element-by-element.
TMatrixTSparse< Element > operator*(const TMatrixTSparse< Element > &source1, const TMatrixTSparse< Element > &source2)
TMatrixTSparse< Element > operator-(const TMatrixTSparse< Element > &source1, const TMatrixTSparse< Element > &source2)
Bool_t AreCompatible(const TMatrixTSparse< Element > &m1, const TMatrixTSparse< Element > &m2, Int_t verbose=0)
TMatrixTSparse< Element > & Add(TMatrixTSparse< Element > &target, Element scalar, const TMatrixTSparse< Element > &source)
Modify addition: target += scalar * source.
TMatrixTSparse< Element > operator+(const TMatrixTSparse< Element > &source1, const TMatrixTSparse< Element > &source2)
TMatrixTSparse< Element > & ElementMult(TMatrixTSparse< Element > &target, const TMatrixTSparse< Element > &source)
Multiply target by the source, element-by-element.
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
TMatrixTBase.
TMatrixTSparse.
TMatrixTBase< Element > & Randomize(Element alpha, Element beta, Double_t &seed) override
randomize matrix element values
TMatrixTBase< Element > & SetMatrixArray(const Element *data, Option_t *="") override
Copy array data to matrix .
Int_t * GetRowIndexArray() override
Int_t * GetColIndexArray() override
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][col_lwb..col_upb]; The indexing range of the returned matrix depends...
TMatrixTSparse< Element > & operator+=(Element val)
Add val to every element of the matrix.
TMatrixTBase< Element > & ResizeTo(const TMatrixTSparse< Element > &m)
static TClass * Class()
TMatrixTSparse< Element > & SetSparseIndex(Int_t nelem_new)
Increase/decrease the number of non-zero elements to nelems_new.
~TMatrixTSparse() override
TMatrixTSparse< Element > & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t nr_nonzeros, Int_t *pRowIndex, Int_t *pColIndex, Element *pData)
TMatrixTBase< Element > & InsertRow(Int_t row, Int_t col, const Element *v, Int_t n=-1) override
Insert in row rown, n elements of array v at column coln.
TMatrixTSparse< Element > & operator+=(const TMatrixTSparse< Element > &source)
Element ColNorm() const override
Column matrix norm, MAX{ SUM{ |M(i,j)|, over i}, over j}.
const Int_t * GetRowIndexArray() const override
TMatrixTSparse< Element > & operator-=(const TMatrixTSparse< Element > &source)
void AMinusB(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
General matrix subtraction.
TMatrixTSparse< Element > & operator*=(Element val)
Multiply every element of the matrix with val.
void AMultB(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
void AMultBt(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
General matrix multiplication.
void GetMatrix2Array(Element *data, Option_t *="") const override
Copy matrix data to array . It is assumed that array is of size >= fNelems.
TMatrixTSparse< Element > & Transpose(const TMatrixTSparse< Element > &source)
Transpose a matrix. Set the matrix to ncols x nrows if nrows != ncols.
TMatrixTSparse< Element > & operator*=(const TMatrixTSparse< Element > &source)
TMatrixTSparse< Element > & operator-=(Element val)
Subtract val from every element of the matrix.
TMatrixTSparse< Element > & operator+=(const TMatrixT< Element > &source)
TMatrixTBase< Element > & SetColIndexArray(Int_t *data) override
void APlusB(const TMatrixT< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
Int_t NonZeros() const override
Compute the number of elements != 0.0.
TMatrixTSparseRow< Element > operator[](Int_t rown)
TMatrixTSparse< Element > & operator*=(const TMatrixT< Element > &source)
const TMatrixTSparse< Element > & Use(const TMatrixTSparse< Element > &a) const
Element * fElements
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....
void Allocate(Int_t nrows, Int_t ncols, Int_t row_lwb=0, Int_t col_lwb=0, Int_t init=0, Int_t nr_nonzeros=0)
Allocate new matrix.
void Clear(Option_t *="") override
void AMultB(const TMatrixT< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
const TMatrixTSparseRow_const< Element > operator[](Int_t rown) const
TMatrixTBase< Element > & SetRowIndexArray(Int_t *data) override
TMatrixTBase< Element > & ResizeTo(Int_t nrows, Int_t ncols, Int_t nr_nonzeros=-1) override
Set size of the matrix to nrows x ncols with nr_nonzeros non-zero entries if nr_nonzeros > 0 .
void APlusB(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b, Int_t constr=0)
General matrix addition.
const TMatrixTSparse< Element > & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t nr_nonzeros, const Int_t *pRowIndex, const Int_t *pColIndex, const Element *pData) const
virtual TMatrixTSparse< Element > & RandomizePD(Element alpha, Element beta, Double_t &seed)
randomize matrix element values but keep matrix symmetric positive definite
TMatrixTBase< Element > & Zero() override
Set matrix elements to zero.
TMatrixTSparse< Element > & Use(TMatrixTSparse< Element > &a)
TMatrixTSparse< Element > & operator=(const TMatrixT< Element > &source)
Notice that the sparsity of the matrix is NOT changed : its fRowIndex/fColIndex are used !
TMatrixTBase< Element > & NormByDiag(const TVectorT< Element > &, Option_t *) override
option:
TMatrixTSparse< Element > & T()
const Int_t * GetColIndexArray() const override
void AMultB(const TMatrixTSparse< Element > &a, const TMatrixT< Element > &b, Int_t constr=0)
Element operator()(Int_t rown, Int_t coln) const override
const TMatrixTSparse< Element > & Use(Int_t nrows, Int_t ncols, Int_t nr_nonzeros, const Int_t *pRowIndex, const Int_t *pColIndex, const Element *pData) const
TMatrixTSparse< Element > & SetSparseIndexAB(const TMatrixTSparse< Element > &a, const TMatrixT< Element > &b)
TMatrixTSparse< Element > GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t *option="S") const
void ExtractRow(Int_t row, Int_t col, Element *v, Int_t n=-1) const override
Store in array v, n matrix elements of row rown starting at column coln.
TMatrixTSparse< Element > & operator-=(const TMatrixT< Element > &source)
Bool_t IsSymmetric() const override
Check whether matrix is symmetric.
TMatrixTBase< Element > & UnitMatrix() override
Make a unit matrix (matrix need not be a square one).
Element RowNorm() const override
Row matrix norm, MAX{ SUM{ |M(i,j)|, over j}, over i}.
TMatrixTSparse< Element > & SetSparseIndexAB(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b)
Set the row/column indices to the "sum" of matrices a and b It is checked that enough space has been ...
void Mult(const TMatrixTSparse< Element > &a, const TMatrixTSparse< Element > &b)
const Element * GetMatrixArray() const override
Element * GetMatrixArray() override
TMatrixTSparse< Element > & Use(Int_t nrows, Int_t ncols, Int_t nr_nonzeros, Int_t *pRowIndex, Int_t *pColIndex, Element *pData)
TMatrixT.
Definition TMatrixT.h:39
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:1029
TVectorT.
Definition TVectorT.h:27
const Int_t n
Definition legend1.C:16
TMarker m
Definition textangle.C:8