ROOT logo
ROOT » MATH » MATRIX » TMatrixT<float>

class TMatrixT<float>: public TMatrixTBase<float>


TMatrixT

Template class of a general matrix in the linear algebra package


This class is also known as (typedefs to this class)

TMatrixT<Float_t>, TMatrixF, TMatrix

Function Members (Methods)

public:
TMatrixT<float>()
TMatrixT<float>(const TMatrixT<float>& another)
TMatrixT<float>(const TMatrixTSym<float>& another)
TMatrixT<float>(const TMatrixTSparse<float>& another)
TMatrixT<float>(const TMatrixTLazy<float>& lazy_constructor)
TMatrixT<float>(const TMatrixT<double>& another)
TMatrixT<float>(Int_t nrows, Int_t ncols)
TMatrixT<float>(TMatrixT<float>::EMatrixCreatorsOp1 op, const TMatrixT<float>& prototype)
TMatrixT<float>(const TMatrixT<float>& a, TMatrixT<float>::EMatrixCreatorsOp2 op, const TMatrixT<float>& b)
TMatrixT<float>(const TMatrixT<float>& a, TMatrixT<float>::EMatrixCreatorsOp2 op, const TMatrixTSym<float>& b)
TMatrixT<float>(const TMatrixTSym<float>& a, TMatrixT<float>::EMatrixCreatorsOp2 op, const TMatrixT<float>& b)
TMatrixT<float>(const TMatrixTSym<float>& a, TMatrixT<float>::EMatrixCreatorsOp2 op, const TMatrixTSym<float>& b)
TMatrixT<float>(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb)
TMatrixT<float>(Int_t nrows, Int_t ncols, const float* data, Option_t* option = "")
TMatrixT<float>(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, const float* data, Option_t* option = "")
virtual~TMatrixT<float>()
virtual TMatrixTBase<float>&TMatrixTBase<float>::Abs()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual TMatrixTBase<float>&TMatrixTBase<float>::Apply(const TElementActionT<float>& action)
virtual TMatrixTBase<float>&TMatrixTBase<float>::Apply(const TElementPosActionT<float>& action)
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidClear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual floatTMatrixTBase<float>::ColNorm() const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Double_tDeterminant() const
virtual voidDeterminant(Double_t& d1, Double_t& d2) const
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTMatrixTBase<float>::Draw(Option_t* option = "")MENU
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual floatTMatrixTBase<float>::E2Norm() const
const TMatrixT<float>EigenVectors(TVectorT<float>& eigenValues) const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTMatrixTBase<float>::ExtractRow(Int_t row, Int_t col, float* v, Int_t n = -1) const
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual const Int_t*GetColIndexArray() const
virtual Int_t*GetColIndexArray()
Int_tTMatrixTBase<float>::GetColLwb() const
Int_tTMatrixTBase<float>::GetColUpb() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual voidTMatrixTBase<float>::GetMatrix2Array(float* data, Option_t* option = "") const
virtual const float*GetMatrixArray() const
virtual float*GetMatrixArray()
virtual const char*TObject::GetName() const
Int_tTMatrixTBase<float>::GetNcols() const
Int_tTMatrixTBase<float>::GetNoElements() const
Int_tTMatrixTBase<float>::GetNrows() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual const Int_t*GetRowIndexArray() const
virtual Int_t*GetRowIndexArray()
Int_tTMatrixTBase<float>::GetRowLwb() const
Int_tTMatrixTBase<float>::GetRowUpb() const
TMatrixT<float>GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t* option = "S") const
virtual TMatrixTBase<float>&GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, TMatrixTBase<float>& target, Option_t* option = "S") const
virtual const char*TObject::GetTitle() const
floatTMatrixTBase<float>::GetTol() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual TMatrixTBase<float>&TMatrixTBase<float>::InsertRow(Int_t row, Int_t col, const float* v, Int_t n = -1)
virtual voidTObject::Inspect() constMENU
voidTMatrixTBase<float>::Invalidate()
TMatrixT<float>&Invert(Double_t* det = 0)
voidTObject::InvertBit(UInt_t f)
TMatrixT<float>&InvertFast(Double_t* det = 0)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
Bool_tTMatrixTBase<float>::IsOwner() const
virtual Bool_tTObject::IsSortable() const
virtual Bool_tTMatrixTBase<float>::IsSymmetric() const
Bool_tTMatrixTBase<float>::IsValid() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTMatrixTBase<float>::MakeValid()
virtual floatTMatrixTBase<float>::Max() const
voidTObject::MayNotUse(const char* method) const
virtual floatTMatrixTBase<float>::Min() const
voidMinus(const TMatrixT<float>& a, const TMatrixT<float>& b)
voidMinus(const TMatrixT<float>& a, const TMatrixTSym<float>& b)
voidMinus(const TMatrixTSym<float>& a, const TMatrixT<float>& b)
voidMult(const TMatrixT<float>& a, const TMatrixT<float>& b)
voidMult(const TMatrixT<float>& a, const TMatrixTSym<float>& b)
voidMult(const TMatrixTSym<float>& a, const TMatrixT<float>& b)
voidMult(const TMatrixTSym<float>& a, const TMatrixTSym<float>& b)
voidMultT(const TMatrixT<float>& a, const TMatrixT<float>& b)
voidMultT(const TMatrixT<float>& a, const TMatrixTSym<float>& b)
voidMultT(const TMatrixTSym<float>& a, const TMatrixT<float>& b)
voidMultT(const TMatrixTSym<float>& a, const TMatrixTSym<float>& b)
virtual Int_tTMatrixTBase<float>::NonZeros() const
floatTMatrixTBase<float>::Norm1() const
TMatrixT<float>&NormByColumn(const TVectorT<float>& v, Option_t* option = "D")
virtual TMatrixTBase<float>&TMatrixTBase<float>::NormByDiag(const TVectorT<float>& v, Option_t* option = "D")
TMatrixT<float>&NormByRow(const TVectorT<float>& v, Option_t* option = "D")
floatTMatrixTBase<float>::NormInf() const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
Bool_tTMatrixTBase<float>::operator!=(float val) const
virtual floatoperator()(Int_t rown, Int_t coln) const
virtual float&operator()(Int_t rown, Int_t coln)
TMatrixT<float>&operator*=(float val)
TMatrixT<float>&operator*=(const TMatrixT<float>& source)
TMatrixT<float>&operator*=(const TMatrixTSym<float>& source)
TMatrixT<float>&operator*=(const TMatrixTDiag_const<float>& diag)
TMatrixT<float>&operator*=(const TMatrixTRow_const<float>& row)
TMatrixT<float>&operator*=(const TMatrixTColumn_const<float>& col)
TMatrixT<float>&operator+=(float val)
TMatrixT<float>&operator+=(const TMatrixT<float>& source)
TMatrixT<float>&operator+=(const TMatrixTSym<float>& source)
TMatrixT<float>&operator-=(float val)
TMatrixT<float>&operator-=(const TMatrixT<float>& source)
TMatrixT<float>&operator-=(const TMatrixTSym<float>& source)
TMatrixT<float>&operator/=(const TMatrixTDiag_const<float>& diag)
TMatrixT<float>&operator/=(const TMatrixTRow_const<float>& row)
TMatrixT<float>&operator/=(const TMatrixTColumn_const<float>& col)
Bool_tTMatrixTBase<float>::operator<(float val) const
Bool_tTMatrixTBase<float>::operator<=(float val) const
TMatrixT<float>&operator=(const TMatrixT<float>& source)
TMatrixT<float>&operator=(const TMatrixTSym<float>& source)
TMatrixT<float>&operator=(const TMatrixTSparse<float>& source)
TMatrixT<float>&operator=(const TMatrixTLazy<float>& source)
TMatrixT<float>&operator=(float val)
Bool_tTMatrixTBase<float>::operator==(float val) const
Bool_tTMatrixTBase<float>::operator>(float val) const
Bool_tTMatrixTBase<float>::operator>=(float val) const
const TMatrixTRow_const<float>operator[](Int_t rown) const
TMatrixTRow<float>operator[](Int_t rown)
virtual voidTObject::Paint(Option_t* option = "")
voidPlus(const TMatrixT<float>& a, const TMatrixT<float>& b)
voidPlus(const TMatrixT<float>& a, const TMatrixTSym<float>& b)
voidPlus(const TMatrixTSym<float>& a, const TMatrixT<float>& b)
virtual voidTObject::Pop()
virtual voidTMatrixTBase<float>::Print(Option_t* name = "") constMENU
virtual TMatrixTBase<float>&TMatrixTBase<float>::Randomize(float alpha, float beta, Double_t& seed)
TMatrixT<float>&Rank1Update(const TVectorT<float>& v, float alpha = 1.0)
TMatrixT<float>&Rank1Update(const TVectorT<float>& v1, const TVectorT<float>& v2, float alpha = 1.0)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
TMatrixTBase<float>&ResizeTo(const TMatrixT<float>& m)
virtual TMatrixTBase<float>&ResizeTo(Int_t nrows, Int_t ncols, Int_t = -1)
virtual TMatrixTBase<float>&ResizeTo(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t = -1)
virtual floatTMatrixTBase<float>::RowNorm() const
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual TMatrixTBase<float>&SetColIndexArray(Int_t*)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
virtual TMatrixTBase<float>&TMatrixTBase<float>::SetMatrixArray(const float* data, Option_t* option = "")
static voidTObject::SetObjectStat(Bool_t stat)
virtual TMatrixTBase<float>&SetRowIndexArray(Int_t*)
virtual TMatrixTBase<float>&SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixTBase<float>& source)
floatTMatrixTBase<float>::SetTol(float newTol)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual TMatrixTBase<float>&TMatrixTBase<float>::Shift(Int_t row_shift, Int_t col_shift)
virtual voidShowMembers(TMemberInspector&)
floatSimilarity(const TVectorT<float>& v) const
virtual TMatrixTBase<float>&TMatrixTBase<float>::Sqr()
virtual TMatrixTBase<float>&TMatrixTBase<float>::Sqrt()
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual floatTMatrixTBase<float>::Sum() const
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
TMatrixT<float>&T()
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTMult(const TMatrixT<float>& a, const TMatrixT<float>& b)
voidTMult(const TMatrixT<float>& a, const TMatrixTSym<float>& b)
voidTMult(const TMatrixTSym<float>& a, const TMatrixT<float>& b)
voidTMult(const TMatrixTSym<float>& a, const TMatrixTSym<float>& b)
TMatrixT<float>&Transpose(const TMatrixT<float>& source)
virtual TMatrixTBase<float>&TMatrixTBase<float>::UnitMatrix()
TMatrixT<float>&Use(TMatrixT<float>& a)
const TMatrixT<float>&Use(const TMatrixT<float>& a) const
TMatrixT<float>&Use(Int_t nrows, Int_t ncols, float* data)
const TMatrixT<float>&Use(Int_t nrows, Int_t ncols, const float* data) const
TMatrixT<float>&Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, float* data)
const TMatrixT<float>&Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, const float* data) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
virtual TMatrixTBase<float>&TMatrixTBase<float>::Zero()
protected:
voidAllocate(Int_t nrows, Int_t ncols, Int_t row_lwb = 0, Int_t col_lwb = 0, Int_t init = 0, Int_t = -1)
voidDelete_m(Int_t size, float*&)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
static voidTMatrixTBase<float>::DoubleLexSort(Int_t n, Int_t* first, Int_t* second, float* data)
static voidTMatrixTBase<float>::IndexedLexSort(Int_t n, Int_t* first, Int_t swapFirst, Int_t* second, Int_t swapSecond, Int_t* index)
voidTObject::MakeZombie()
Int_tMemcpy_m(float* newp, const float* oldp, Int_t copySize, Int_t newSize, Int_t oldSize)
static float&NaNValue()
float*New_m(Int_t size)

Data Members

public:
enum { kWorkMax
};
enum EMatrixCreatorsOp1 { kZero
kUnit
kTransposed
kInverted
kAtA
};
enum EMatrixCreatorsOp2 { kMult
kTransposeMult
kInvMult
kMultTranspose
kPlus
kMinus
};
enum TMatrixTBase::[unnamed] { kSizeMax
kWorkMax
};
enum TMatrixTBase::EMatrixStatusBits { kStatus
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
Int_tTMatrixTBase<float>::fColLwblower bound of the col index
floatfDataStack[25]! data container
float*fElements[fNelems] elements themselves
Bool_tTMatrixTBase<float>::fIsOwner!default kTRUE, when Use array kFALSE
Int_tTMatrixTBase<float>::fNcolsnumber of columns
Int_tTMatrixTBase<float>::fNelemsnumber of elements in matrix
Int_tTMatrixTBase<float>::fNrowIndexlength of row index array (= fNrows+1) wich is only used for sparse matrices
Int_tTMatrixTBase<float>::fNrowsnumber of rows
Int_tTMatrixTBase<float>::fRowLwblower bound of the row index
floatTMatrixTBase<float>::fTolsqrt(epsilon); epsilon is smallest number number so that 1+epsilon > 1

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void TMatrixT<Element> Delete_m(Int_t size, float*& )
 Delete data pointer m, if it was assigned on the heap
Element* TMatrixT<Element> New_m(Int_t size)
 Return data pointer . if requested size <= kSizeMax, assign pointer
 to the stack space
Int_t TMatrixT<Element> Memcpy_m(float* newp, const float* oldp, Int_t copySize, Int_t newSize, Int_t oldSize)
 Copy copySize doubles from *oldp to *newp . However take care of the
 situation where both pointers are assigned to the same stack space
void TMatrixT<Element> Allocate(Int_t nrows, Int_t ncols, Int_t row_lwb = 0, Int_t col_lwb = 0, Int_t init = 0, Int_t = -1)
 Allocate new matrix. Arguments are number of rows, columns, row
 lowerbound (0 default) and column lowerbound (0 default).
void TMatrixT<Element> Plus(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
 General matrix summation. Create a matrix C such that C = A + B.
void TMatrixT<Element> Plus(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
 General matrix summation. Create a matrix C such that C = A + B.
void TMatrixT<Element> Minus(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
 General matrix summation. Create a matrix C such that C = A - B.
void TMatrixT<Element> Minus(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
 General matrix summation. Create a matrix C such that C = A - B.
void TMatrixT<Element> Mult(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
 General matrix multiplication. Create a matrix C such that C = A * B.
void TMatrixT<Element> Mult(const TMatrixTSym<Element> &a,const TMatrixT<Element> &b)
 Matrix multiplication, with A symmetric and B general.
 Create a matrix C such that C = A * B.
void TMatrixT<Element> Mult(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
 Matrix multiplication, with A general and B symmetric.
 Create a matrix C such that C = A * B.
void TMatrixT<Element> Mult(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b)
 Matrix multiplication, with A symmetric and B symmetric.
 (Actually copied for the moment routine for B general)
 Create a matrix C such that C = A * B.
void TMatrixT<Element> TMult(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
 Create a matrix C such that C = A' * B. In other words,
 c[i,j] = SUM{ a[k,i] * b[k,j] }.
void TMatrixT<Element> TMult(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
 Create a matrix C such that C = A' * B. In other words,
 c[i,j] = SUM{ a[k,i] * b[k,j] }.
void TMatrixT<Element> MultT(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
 General matrix multiplication. Create a matrix C such that C = A * B^T.
void TMatrixT<Element> MultT(const TMatrixTSym<Element> &a,const TMatrixT<Element> &b)
 Matrix multiplication, with A symmetric and B general.
 Create a matrix C such that C = A * B^T.
TMatrixT<Element> &TMatrixT<Element> Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, float* data)
 Use the array data to fill the matrix ([row_lwb..row_upb] x [col_lwb..col_upb])
TMatrixTBase<Element> &TMatrixT<Element> GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, TMatrixTBase<float>& target, Option_t* option = "S") const
 Get submatrix [row_lwb..row_upb] x [col_lwb..col_upb]; The indexing range of the
 returned matrix depends on the argument option:

 option == "S" : return [0..row_upb-row_lwb][0..col_upb-col_lwb] (default)
 else          : return [row_lwb..row_upb][col_lwb..col_upb]
TMatrixTBase<Element> &TMatrixT<Element> SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixTBase<float>& source)
 Insert matrix source starting at [row_lwb][col_lwb], thereby overwriting the part
 [row_lwb..row_lwb+nrows_source][col_lwb..col_lwb+ncols_source];
TMatrixTBase<Element> &TMatrixT<Element> ResizeTo(Int_t nrows, Int_t ncols, Int_t = -1)
 Set size of the matrix to nrows x ncols
 New dynamic elements are created, the overlapping part of the old ones are
 copied to the new structures, then the old elements are deleted.
TMatrixTBase<Element> &TMatrixT<Element> ResizeTo(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t = -1)
 Set size of the matrix to [row_lwb:row_upb] x [col_lwb:col_upb]
 New dynamic elemenst are created, the overlapping part of the old ones are
 copied to the new structures, then the old elements are deleted.
Double_t TMatrixT<Element> Determinant() const
 Return the matrix determinant
void TMatrixT<Element> Determinant(Double_t& d1, Double_t& d2) const
 Return the matrix determinant as d1,d2 where det = d1*TMath::Power(2.0,d2)
TMatrixT<Double_t> &TMatrixT<Double_t> Invert(Double_t* det = 0)
 Invert the matrix and calculate its determinant
TMatrixT<Element> &TMatrixT<Element> InvertFast(Double_t* det = 0)
 Invert the matrix and calculate its determinant, however upto (6x6)
 a fast Cramer inversion is used .
TMatrixT<Element> &TMatrixT<Element> Transpose(const TMatrixT<float>& source)
 Transpose matrix source.
TMatrixT<Element> &TMatrixT<Element> Rank1Update(const TVectorT<float>& v, float alpha = 1.0)
 Perform a rank 1 operation on matrix A:
     A += alpha * v * v^T
TMatrixT<Element> &TMatrixT<Element> Rank1Update(const TVectorT<float>& v1, const TVectorT<float>& v2, float alpha = 1.0)
 Perform a rank 1 operation on matrix A:
     A += alpha * v1 * v2^T
Element TMatrixT<Element> Similarity(const TVectorT<float>& v) const
 Calculate scalar v * (*this) * v^T
TMatrixT<Element> &TMatrixT<Element> NormByColumn(const TVectorT<float>& v, Option_t* option = "D")
 Multiply/divide matrix columns by a vector:
 option:
 "D"   :  b(i,j) = a(i,j)/v(i)   i = 0,fNrows-1 (default)
 else  :  b(i,j) = a(i,j)*v(i)
TMatrixT<Element> &TMatrixT<Element> NormByRow(const TVectorT<float>& v, Option_t* option = "D")
 Multiply/divide matrix rows with a vector:
 option:
 "D"   :  b(i,j) = a(i,j)/v(j)   i = 0,fNcols-1 (default)
 else  :  b(i,j) = a(i,j)*v(j)
TMatrixT<Element> &TMatrixT<Element> operator=(const TMatrixT<Element> &source)
 Assignment operator
TMatrixT<Element> &TMatrixT<Element> operator=(const TMatrixTSym<Element> &source)
 Assignment operator
TMatrixT<Element> &TMatrixT<Element> operator=(const TMatrixTSparse<Element> &source)
 Assignment operator
TMatrixT<Element> &TMatrixT<Element> operator=(const TMatrixTLazy<Element> &lazy_constructor)
 Assignment operator
TMatrixT<Element> &TMatrixT<Element> operator=(Element val)
 Assign val to every element of the matrix.
TMatrixT<Element> &TMatrixT<Element> operator+=(Element val)
 Add val to every element of the matrix.
TMatrixT<Element> &TMatrixT<Element> operator-=(Element val)
 Subtract val from every element of the matrix.
TMatrixT<Element> &TMatrixT<Element> operator*=(Element val)
 Multiply every element of the matrix with val.
TMatrixT<Element> &TMatrixT<Element> operator+=(const TMatrixT<Element> &source)
 Add the source matrix.
TMatrixT<Element> &TMatrixT<Element> operator+=(const TMatrixTSym<Element> &source)
 Add the source matrix.
TMatrixT<Element> &TMatrixT<Element> operator-=(const TMatrixT<Element> &source)
 Subtract the source matrix.
TMatrixT<Element> &TMatrixT<Element> operator-=(const TMatrixTSym<Element> &source)
 Subtract the source matrix.
TMatrixT<Element> &TMatrixT<Element> operator*=(const TMatrixT<Element> &source)
 Compute target = target * source inplace. Strictly speaking, it can't be
 done inplace, though only the row of the target matrix needs to be saved.
 "Inplace" multiplication is only allowed when the 'source' matrix is square.
TMatrixT<Element> &TMatrixT<Element> operator*=(const TMatrixTSym<Element> &source)
 Compute target = target * source inplace. Strictly speaking, it can't be
 done inplace, though only the row of the target matrix needs to be saved.
TMatrixT<Element> &TMatrixT<Element> operator*=(const TMatrixTDiag_const<Element> &diag)
 Multiply a matrix row by the diagonal of another matrix
 matrix(i,j) *= diag(j), j=0,fNcols-1
TMatrixT<Element> &TMatrixT<Element> operator/=(const TMatrixTDiag_const<Element> &diag)
 Divide a matrix row by the diagonal of another matrix
 matrix(i,j) /= diag(j)
TMatrixT<Element> &TMatrixT<Element> operator*=(const TMatrixTColumn_const<Element> &col)
 Multiply a matrix by the column of another matrix
 matrix(i,j) *= another(i,k) for fixed k
TMatrixT<Element> &TMatrixT<Element> operator/=(const TMatrixTColumn_const<Element> &col)
 Divide a matrix by the column of another matrix
 matrix(i,j) /= another(i,k) for fixed k
TMatrixT<Element> &TMatrixT<Element> operator*=(const TMatrixTRow_const<Element> &row)
 Multiply a matrix by the row of another matrix
 matrix(i,j) *= another(k,j) for fixed k
TMatrixT<Element> &TMatrixT<Element> operator/=(const TMatrixTRow_const<Element> &row)
 Divide a matrix by the row of another matrix
 matrix(i,j) /= another(k,j) for fixed k
const TMatrixT<Element> TMatrixT<Element> EigenVectors(TVectorT<float>& eigenValues) const
 Return a matrix containing the eigen-vectors ordered by descending values
 of Re^2+Im^2 of the complex eigen-values .
 If the matrix is asymmetric, only the real part of the eigen-values is
 returned . For full functionality use TMatrixDEigen .
void TMatrixT<Element> Streamer(TBuffer& )
 Stream an object of class TMatrixT.
Element & TMatrixT<Element> NaNValue()
template <class Element> inline const Element *TMatrixT<Element> GetMatrixArray() const
{ return fElements; }
template <class Element> inline Element *TMatrixT<Element> GetMatrixArray()
{ return fElements; }
template <class Element> inline TMatrixT<Element> &TMatrixT<Element> Use(Int_t nrows, Int_t ncols, float* data)
{ return Use(0,nrows-1,0,ncols-1,data); }
template <class Element> inline const TMatrixT<Element> &TMatrixT<Element> Use(Int_t nrows, Int_t ncols, const float* data) const
{ return Use(0,nrows-1,0,ncols-1,data); }
template <class Element> inline TMatrixT<Element> &TMatrixT<Element> Use(TMatrixT<float>& a)
template <class Element> inline const TMatrixT<Element> &TMatrixT<Element> Use(const TMatrixT<float>& a) const
template <class Element> inline TMatrixT<Element> TMatrixT<Element> GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t* option = "S") const
template <class Element> inline Element TMatrixT<Element> operator()(Int_t rown, Int_t coln) const
template <class Element> inline Element &TMatrixT<Element> operator()(Int_t rown, Int_t coln)
void Plus(const TMatrixT <Element> &a,const TMatrixT <Element> &b)
 Elementary constructors
void Minus(const TMatrixT <Element> &a,const TMatrixT <Element> &b)
void TMult(const TMatrixT <Element> &a,const TMatrixT <Element> &b)
void TMult(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b)
void MultT(const TMatrixT <Element> &a,const TMatrixT <Element> &b)
void MultT(const TMatrixT <Element> &a,const TMatrixTSym<Element> &b)
{ Mult(a,b); }
const Int_t * GetRowIndexArray() const
{ return 0; }
Int_t * GetRowIndexArray()
{ return 0; }
const Int_t * GetColIndexArray() const
{ return 0; }
Int_t * GetColIndexArray()
{ return 0; }
TMatrixTBase<Element> & SetRowIndexArray(Int_t* )
{ MayNotUse("SetRowIndexArray(Int_t *)"); return *this; }
TMatrixTBase<Element> & SetColIndexArray(Int_t* )
{ MayNotUse("SetColIndexArray(Int_t *)"); return *this; }
void Clear(Option_t* = "")
TMatrixT <Element> & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, float* data)
TMatrixTBase<Element> & ResizeTo(Int_t nrows, Int_t ncols, Int_t = -1)
const TMatrixTRow_const<Element> operator[](Int_t rown) const
 or as a[i][j]
{ return TMatrixTRow_const<Element>(*this,rown); }
TMatrixTRow <Element> operator[](Int_t rown)
{ return TMatrixTRow <Element>(*this,rown); }