#ifndef ROOT_TMatrixTUtils
#define ROOT_TMatrixTUtils
#ifndef ROOT_TMatrixTBase
#include "TMatrixTBase.h"
#endif
template<class Element> class TVectorT;
template<class Element> class TMatrixT;
template<class Element> class TMatrixTSym;
template<class Element> class TMatrixTSparse;
template<class Element> class TElementActionT {
#ifndef __CINT__
friend class TMatrixTBase <Element>;
friend class TMatrixT <Element>;
friend class TMatrixTSym <Element>;
friend class TMatrixTSparse<Element>;
friend class TVectorT <Element>;
#endif
protected:
virtual ~TElementActionT() { }
virtual void Operation(Element &element) const = 0;
private:
TElementActionT& operator=(const TElementActionT<Element> &) {return *this;}
};
template<class Element> class TElementPosActionT {
#ifndef __CINT__
friend class TMatrixTBase <Element>;
friend class TMatrixT <Element>;
friend class TMatrixTSym <Element>;
friend class TMatrixTSparse<Element>;
friend class TVectorT <Element>;
#endif
protected:
mutable Int_t fI;
mutable Int_t fJ;
virtual ~TElementPosActionT() { }
virtual void Operation(Element &element) const = 0;
private:
TElementPosActionT<Element>& operator=(const TElementPosActionT<Element> &) {return *this;}
};
template<class Element> class TMatrixTRow_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fRowInd;
Int_t fInc;
const Element *fPtr;
public:
TMatrixTRow_const() { fMatrix = 0; fInc = 0; fPtr = 0; }
TMatrixTRow_const(const TMatrixT <Element> &matrix,Int_t row);
TMatrixTRow_const(const TMatrixTSym<Element> &matrix,Int_t row);
TMatrixTRow_const(const TMatrixTRow_const<Element>& trc):
fMatrix(trc.fMatrix), fRowInd(trc.fRowInd), fInc(trc.fInc), fPtr(trc.fPtr) { }
TMatrixTRow_const<Element>& operator=(const TMatrixTRow_const<Element>& trc) {
fMatrix=trc.fMatrix; fRowInd=trc.fRowInd; fInc=trc.fInc; fPtr=trc.fPtr; return *this;}
virtual ~TMatrixTRow_const() { }
inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
inline Int_t GetRowIndex() const { return fRowInd; }
inline Int_t GetInc () const { return fInc; }
inline const Element *GetPtr () const { return fPtr; }
inline const Element &operator ()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
const Int_t acoln = i-fMatrix->GetColLwb();
if (acoln < fMatrix->GetNcols() && acoln >= 0)
return fPtr[acoln];
else {
Error("operator()","Request col(%d) outside matrix range of %d - %d",
i,fMatrix->GetColLwb(),fMatrix->GetColLwb()+fMatrix->GetNcols());
return fPtr[0];
}
}
inline const Element &operator [](Int_t i) const { return (*(const TMatrixTRow_const<Element> *)this)(i); }
ClassDef(TMatrixTRow_const,0)
};
template<class Element> class TMatrixTRow : public TMatrixTRow_const<Element> {
public:
TMatrixTRow() {}
TMatrixTRow(TMatrixT <Element> &matrix,Int_t row);
TMatrixTRow(TMatrixTSym<Element> &matrix,Int_t row);
TMatrixTRow(const TMatrixTRow<Element> &mr);
inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
inline const Element &operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
const Int_t acoln = i-this->fMatrix->GetColLwb();
if (acoln < this->fMatrix->GetNcols() || acoln >= 0)
return (this->fPtr)[acoln];
else {
Error("operator()","Request col(%d) outside matrix range of %d - %d",
i,this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
return (this->fPtr)[0];
}
}
inline Element &operator()(Int_t i) {
R__ASSERT(this->fMatrix->IsValid());
const Int_t acoln = i-this->fMatrix->GetColLwb();
if (acoln < this->fMatrix->GetNcols() && acoln >= 0)
return (const_cast<Element *>(this->fPtr))[acoln];
else {
Error("operator()","Request col(%d) outside matrix range of %d - %d",
i,this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
return (const_cast<Element *>(this->fPtr))[0];
}
}
inline const Element &operator[](Int_t i) const { return (*(const TMatrixTRow<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*( TMatrixTRow<Element> *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTRow_const<Element> &r);
TMatrixTRow<Element>& operator=(const TMatrixTRow <Element> &r) { operator=((TMatrixTRow_const<Element> &)r); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTRow_const<Element> &r);
void operator*=(const TMatrixTRow_const<Element> &r);
ClassDef(TMatrixTRow,0)
};
template<class Element> class TMatrixTColumn_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fColInd;
Int_t fInc;
const Element *fPtr;
public:
TMatrixTColumn_const() { fMatrix = 0; fInc = 0; fPtr = 0; }
TMatrixTColumn_const(const TMatrixT <Element> &matrix,Int_t col);
TMatrixTColumn_const(const TMatrixTSym<Element> &matrix,Int_t col);
TMatrixTColumn_const(const TMatrixTColumn_const<Element>& trc):
fMatrix(trc.fMatrix), fColInd(trc.fColInd), fInc(trc.fInc), fPtr(trc.fPtr) { }
TMatrixTColumn_const<Element>& operator=(const TMatrixTColumn_const<Element>& trc) {
fMatrix=trc.fMatrix; fColInd=trc.fColInd; fInc=trc.fInc; fPtr=trc.fPtr; return *this;}
virtual ~TMatrixTColumn_const() { }
inline const TMatrixTBase <Element> *GetMatrix () const { return fMatrix; }
inline Int_t GetColIndex() const { return fColInd; }
inline Int_t GetInc () const { return fInc; }
inline const Element *GetPtr () const { return fPtr; }
inline const Element &operator ()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
const Int_t arown = i-fMatrix->GetRowLwb();
if (arown < fMatrix->GetNrows() && arown >= 0)
return fPtr[arown*fInc];
else {
Error("operator()","Request row(%d) outside matrix range of %d - %d",
i,fMatrix->GetRowLwb(),fMatrix->GetRowLwb()+fMatrix->GetNrows());
return fPtr[0];
}
}
inline const Element &operator [](Int_t i) const { return (*(const TMatrixTColumn_const<Element> *)this)(i); }
ClassDef(TMatrixTColumn_const,0)
};
template<class Element> class TMatrixTColumn : public TMatrixTColumn_const<Element> {
public:
TMatrixTColumn() {}
TMatrixTColumn(TMatrixT <Element>&matrix,Int_t col);
TMatrixTColumn(TMatrixTSym<Element>&matrix,Int_t col);
TMatrixTColumn(const TMatrixTColumn <Element>&mc);
inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
inline const Element &operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
const Int_t arown = i-this->fMatrix->GetRowLwb();
if (arown < this->fMatrix->GetNrows() && arown >= 0)
return (this->fPtr)[arown*this->fInc];
else {
Error("operator()","Request row(%d) outside matrix range of %d - %d",
i,this->fMatrix->GetRowLwb(),this->fMatrix->GetRowLwb()+this->fMatrix->GetNrows());
return (this->fPtr)[0];
}
}
inline Element &operator()(Int_t i) {
R__ASSERT(this->fMatrix->IsValid());
const Int_t arown = i-this->fMatrix->GetRowLwb();
R__ASSERT(arown < this->fMatrix->GetNrows() && arown >= 0);
return (const_cast<Element *>(this->fPtr))[arown*this->fInc];
if (arown < this->fMatrix->GetNrows() && arown >= 0)
return (const_cast<Element *>(this->fPtr))[arown*this->fInc];
else {
Error("operator()","Request row(%d) outside matrix range of %d - %d",
i,this->fMatrix->GetRowLwb(),this->fMatrix->GetRowLwb()+this->fMatrix->GetNrows());
return (const_cast<Element *>(this->fPtr))[0];
}
}
inline const Element &operator[](Int_t i) const { return (*(const TMatrixTColumn<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*( TMatrixTColumn<Element> *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTColumn_const<Element> &c);
TMatrixTColumn<Element>& operator=(const TMatrixTColumn <Element> &c) { operator=((TMatrixTColumn_const<Element> &)c); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTColumn_const<Element> &c);
void operator*=(const TMatrixTColumn_const<Element> &c);
ClassDef(TMatrixTColumn,0)
};
template<class Element> class TMatrixTDiag_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fInc;
Int_t fNdiag;
const Element *fPtr;
public:
TMatrixTDiag_const() { fMatrix = 0; fInc = 0; fNdiag = 0; fPtr = 0; }
TMatrixTDiag_const(const TMatrixT <Element> &matrix);
TMatrixTDiag_const(const TMatrixTSym<Element> &matrix);
TMatrixTDiag_const(const TMatrixTDiag_const<Element>& trc):
fMatrix(trc.fMatrix), fInc(trc.fInc), fNdiag(trc.fNdiag), fPtr(trc.fPtr) { }
TMatrixTDiag_const<Element>& operator=(const TMatrixTDiag_const<Element>& trc) {
fMatrix=trc.fMatrix; fInc=trc.fInc; fNdiag=trc.fNdiag; fPtr=trc.fPtr; return *this;}
virtual ~TMatrixTDiag_const() { }
inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
inline const Element *GetPtr () const { return fPtr; }
inline Int_t GetInc () const { return fInc; }
inline const Element &operator ()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
if (i < fNdiag && i >= 0)
return fPtr[i*fInc];
else {
Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,fNdiag);
return fPtr[0];
}
}
inline const Element &operator [](Int_t i) const { return (*(const TMatrixTDiag_const<Element> *)this)(i); }
Int_t GetNdiags() const { return fNdiag; }
ClassDef(TMatrixTDiag_const,0)
};
template<class Element> class TMatrixTDiag : public TMatrixTDiag_const<Element> {
public:
TMatrixTDiag() {}
TMatrixTDiag(TMatrixT <Element>&matrix);
TMatrixTDiag(TMatrixTSym<Element>&matrix);
TMatrixTDiag(const TMatrixTDiag<Element> &md);
inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
inline const Element &operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
if (i < this->fNdiag && i >= 0)
return (this->fPtr)[i*this->fInc];
else {
Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,this->fNdiag);
return (this->fPtr)[0];
}
}
inline Element &operator()(Int_t i) {
R__ASSERT(this->fMatrix->IsValid());
if (i < this->fNdiag && i >= 0)
return (const_cast<Element *>(this->fPtr))[i*this->fInc];
else {
Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,this->fNdiag);
return (const_cast<Element *>(this->fPtr))[0];
}
}
inline const Element &operator[](Int_t i) const { return (*(const TMatrixTDiag<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*( TMatrixTDiag *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTDiag_const<Element> &d);
TMatrixTDiag<Element>& operator=(const TMatrixTDiag <Element> &d) { operator=((TMatrixTDiag_const<Element> &)d); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTDiag_const<Element> &d);
void operator*=(const TMatrixTDiag_const<Element> &d);
ClassDef(TMatrixTDiag,0)
};
template<class Element> class TMatrixTFlat_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fNelems;
const Element *fPtr;
public:
TMatrixTFlat_const() { fMatrix = 0; fNelems = 0; fPtr = 0; }
TMatrixTFlat_const(const TMatrixT <Element> &matrix);
TMatrixTFlat_const(const TMatrixTSym<Element> &matrix);
TMatrixTFlat_const(const TMatrixTFlat_const<Element>& trc):
fMatrix(trc.fMatrix), fNelems(trc.fNelems), fPtr(trc.fPtr) { }
TMatrixTFlat_const<Element>& operator=(const TMatrixTFlat_const<Element>& trc) {
fMatrix=trc.fMatrix; fNelems=trc.fNelems; fPtr=trc.fPtr; return *this;}
virtual ~TMatrixTFlat_const() { }
inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
inline const Element *GetPtr () const { return fPtr; }
inline const Element &operator ()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
if (i < fNelems && i >= 0)
return fPtr[i];
else {
Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,fNelems);
return fPtr[0];
}
}
inline const Element &operator [](Int_t i) const { return (*(const TMatrixTFlat_const<Element> *)this)(i); }
ClassDef(TMatrixTFlat_const,0)
};
template<class Element> class TMatrixTFlat : public TMatrixTFlat_const<Element> {
public:
TMatrixTFlat() {}
TMatrixTFlat(TMatrixT <Element> &matrix);
TMatrixTFlat(TMatrixTSym<Element> &matrix);
TMatrixTFlat(const TMatrixTFlat<Element> &mf);
inline Element *GetPtr() const { return const_cast<Element *>(this->fPtr); }
inline const Element &operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
if (i < this->fNelems && i >= 0)
return (this->fPtr)[i];
else {
Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,this->fNelems);
return (this->fPtr)[0];
}
}
inline Element &operator()(Int_t i) {
R__ASSERT(this->fMatrix->IsValid());
if (i < this->fNelems && i >= 0)
return (const_cast<Element *>(this->fPtr))[i];
else {
Error("operator()","Request element(%d) outside matrix range of 0 - %d",i,this->fNelems);
return (const_cast<Element *>(this->fPtr))[0];
}
}
inline const Element &operator[](Int_t i) const { return (*(const TMatrixTFlat<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*( TMatrixTFlat<Element> *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTFlat_const<Element> &f);
TMatrixTFlat<Element>& operator=(const TMatrixTFlat <Element> &f) { operator=((TMatrixTFlat_const<Element> &)f); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTFlat_const<Element> &f);
void operator*=(const TMatrixTFlat_const<Element> &f);
ClassDef(TMatrixTFlat,0)
};
template<class Element> class TMatrixTSub_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fRowOff;
Int_t fColOff;
Int_t fNrowsSub;
Int_t fNcolsSub;
public:
TMatrixTSub_const() { fRowOff = fColOff = fNrowsSub = fNcolsSub = 0; fMatrix = 0; }
TMatrixTSub_const(const TMatrixT <Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
TMatrixTSub_const(const TMatrixTSym<Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
virtual ~TMatrixTSub_const() { }
inline const TMatrixTBase<Element> *GetMatrix() const { return fMatrix; }
inline Int_t GetRowOff() const { return fRowOff; }
inline Int_t GetColOff() const { return fColOff; }
inline Int_t GetNrows () const { return fNrowsSub; }
inline Int_t GetNcols () const { return fNcolsSub; }
inline const Element &operator ()(Int_t rown,Int_t coln) const {
R__ASSERT(fMatrix->IsValid());
const Element *ptr = fMatrix->GetMatrixArray();
if (rown >= fNrowsSub || rown < 0) {
Error("operator()","Request row(%d) outside matrix range of 0 - %d",rown,fNrowsSub);
return ptr[0];
}
if (coln >= fNcolsSub || coln < 0) {
Error("operator()","Request column(%d) outside matrix range of 0 - %d",coln,fNcolsSub);
return ptr[0];
}
const Int_t index = (rown+fRowOff)*fMatrix->GetNcols()+coln+fColOff;
return ptr[index];
}
ClassDef(TMatrixTSub_const,0)
};
template<class Element> class TMatrixTSub : public TMatrixTSub_const<Element> {
public:
enum {kWorkMax = 100};
TMatrixTSub() {}
TMatrixTSub(TMatrixT <Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
TMatrixTSub(TMatrixTSym<Element> &matrix,Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
TMatrixTSub(const TMatrixTSub<Element> &ms);
inline Element &operator()(Int_t rown,Int_t coln) {
R__ASSERT(this->fMatrix->IsValid());
const Element *ptr = this->fMatrix->GetMatrixArray();
if (rown >= this->fNrowsSub || rown < 0) {
Error("operator()","Request row(%d) outside matrix range of 0 - %d",rown,this->fNrowsSub);
return (const_cast<Element *>(ptr))[0];
}
if (coln >= this->fNcolsSub || coln < 0) {
Error("operator()","Request column(%d) outside matrix range of 0 - %d",coln,this->fNcolsSub);
return (const_cast<Element *>(ptr))[0];
}
const Int_t index = (rown+this->fRowOff)*this->fMatrix->GetNcols()+coln+this->fColOff;
return (const_cast<Element *>(ptr))[index];
}
void Rank1Update(const TVectorT<Element> &vec,Element alpha=1.0);
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTSub_const<Element> &s);
TMatrixTSub<Element>& operator=(const TMatrixTSub <Element> &s) { operator=((TMatrixTSub_const<Element> &)s); return *this;}
void operator=(const TMatrixTBase <Element> &m);
void operator+=(const TMatrixTSub_const<Element> &s);
void operator*=(const TMatrixTSub_const<Element> &s);
void operator+=(const TMatrixTBase <Element> &m);
void operator*=(const TMatrixT <Element> &m);
void operator*=(const TMatrixTSym <Element> &m);
ClassDef(TMatrixTSub,0)
};
template<class Element> class TMatrixTSparseRow_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fRowInd;
Int_t fNindex;
const Int_t *fColPtr;
const Element *fDataPtr;
public:
TMatrixTSparseRow_const() { fMatrix = 0; fRowInd = 0; fNindex = 0; fColPtr = 0; fDataPtr = 0; }
TMatrixTSparseRow_const(const TMatrixTSparse<Element> &matrix,Int_t row);
TMatrixTSparseRow_const(const TMatrixTSparseRow_const<Element>& trc):
fMatrix(trc.fMatrix), fRowInd(trc.fRowInd), fNindex(trc.fNindex), fColPtr(trc.fColPtr), fDataPtr(trc.fDataPtr) { }
TMatrixTSparseRow_const<Element>& operator=(const TMatrixTSparseRow_const<Element>& trc) {
fMatrix=trc.fMatrix; fRowInd=trc.fRowInd; fNindex=trc.fNindex; fColPtr=trc.fColPtr; fDataPtr=trc.fDataPtr; return *this;}
virtual ~TMatrixTSparseRow_const() { }
inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
inline const Element *GetDataPtr () const { return fDataPtr; }
inline const Int_t *GetColPtr () const { return fColPtr; }
inline Int_t GetRowIndex() const { return fRowInd; }
inline Int_t GetNindex () const { return fNindex; }
inline Element operator()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
const Int_t acoln = i-fMatrix->GetColLwb();
if (acoln < fMatrix->GetNcols() && acoln >= 0) {
const Int_t index = TMath::BinarySearch(fNindex,fColPtr,acoln);
if (index >= 0 && fColPtr[index] == acoln) return fDataPtr[index];
else return 0.0;
} else {
Error("operator()","Request col(%d) outside matrix range of %d - %d",
i,fMatrix->GetColLwb(),fMatrix->GetColLwb()+fMatrix->GetNcols());
return 0.0;
}
}
inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }
ClassDef(TMatrixTSparseRow_const,0)
};
template<class Element> class TMatrixTSparseRow : public TMatrixTSparseRow_const<Element> {
public:
TMatrixTSparseRow() {}
TMatrixTSparseRow(TMatrixTSparse<Element> &matrix,Int_t row);
TMatrixTSparseRow(const TMatrixTSparseRow<Element> &mr);
inline Element *GetDataPtr() const { return const_cast<Element *>(this->fDataPtr); }
inline Element operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
const Int_t acoln = i-this->fMatrix->GetColLwb();
if (acoln < this->fMatrix->GetNcols() && acoln >= 0) {
const Int_t index = TMath::BinarySearch(this->fNindex,this->fColPtr,acoln);
if (index >= 0 && this->fColPtr[index] == acoln) return this->fDataPtr[index];
else return 0.0;
} else {
Error("operator()","Request col(%d) outside matrix range of %d - %d",
i,this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
return 0.0;
}
}
Element &operator()(Int_t i);
inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseRow<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*(TMatrixTSparseRow<Element> *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTSparseRow_const<Element> &r);
TMatrixTSparseRow<Element>& operator=(const TMatrixTSparseRow <Element> &r) { operator=((TMatrixTSparseRow_const<Element> &)r); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTSparseRow_const<Element> &r);
void operator*=(const TMatrixTSparseRow_const<Element> &r);
ClassDef(TMatrixTSparseRow,0)
};
template<class Element> class TMatrixTSparseDiag_const {
protected:
const TMatrixTBase<Element> *fMatrix;
Int_t fNdiag;
const Element *fDataPtr;
public:
TMatrixTSparseDiag_const() { fMatrix = 0; fNdiag = 0; fDataPtr = 0; }
TMatrixTSparseDiag_const(const TMatrixTSparse<Element> &matrix);
TMatrixTSparseDiag_const(const TMatrixTSparseDiag_const<Element>& trc):
fMatrix(trc.fMatrix), fNdiag(trc.fNdiag), fDataPtr(trc.fDataPtr) { }
TMatrixTSparseDiag_const<Element>& operator=(const TMatrixTSparseDiag_const<Element>& trc) {
fMatrix=trc.fMatrix; fNdiag=trc.fNdiag; fDataPtr=trc.fDataPtr; return *this;}
virtual ~TMatrixTSparseDiag_const() { }
inline const TMatrixTBase<Element> *GetMatrix () const { return fMatrix; }
inline const Element *GetDataPtr() const { return fDataPtr; }
inline Int_t GetNdiags () const { return fNdiag; }
inline Element operator ()(Int_t i) const {
R__ASSERT(fMatrix->IsValid());
if (i < fNdiag && i >= 0) {
const Int_t * const pR = fMatrix->GetRowIndexArray();
const Int_t * const pC = fMatrix->GetColIndexArray();
const Element * const pD = fMatrix->GetMatrixArray();
const Int_t sIndex = pR[i];
const Int_t eIndex = pR[i+1];
const Int_t index = TMath::BinarySearch(eIndex-sIndex,pC+sIndex,i)+sIndex;
if (index >= sIndex && pC[index] == i) return pD[index];
else return 0.0;
} else {
Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,fNdiag);
return 0.0;
}
return 0.0;
}
inline Element operator [](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }
ClassDef(TMatrixTSparseDiag_const,0)
};
template<class Element> class TMatrixTSparseDiag : public TMatrixTSparseDiag_const<Element> {
public:
TMatrixTSparseDiag() {}
TMatrixTSparseDiag(TMatrixTSparse<Element> &matrix);
TMatrixTSparseDiag(const TMatrixTSparseDiag<Element> &md);
inline Element *GetDataPtr() const { return const_cast<Element *>(this->fDataPtr); }
inline Element operator()(Int_t i) const {
R__ASSERT(this->fMatrix->IsValid());
if (i < this->fNdiag && i >= 0) {
const Int_t * const pR = this->fMatrix->GetRowIndexArray();
const Int_t * const pC = this->fMatrix->GetColIndexArray();
const Element * const pD = this->fMatrix->GetMatrixArray();
const Int_t sIndex = pR[i];
const Int_t eIndex = pR[i+1];
const Int_t index = TMath::BinarySearch(eIndex-sIndex,pC+sIndex,i)+sIndex;
if (index >= sIndex && pC[index] == i) return pD[index];
else return 0.0;
} else {
Error("operator()","Request diagonal(%d) outside matrix range of 0 - %d",i,this->fNdiag);
return 0.0;
}
return 0.0;
}
Element &operator()(Int_t i);
inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseDiag<Element> *)this)(i); }
inline Element &operator[](Int_t i) { return (*(TMatrixTSparseDiag<Element> *)this)(i); }
void operator= (Element val);
void operator+=(Element val);
void operator*=(Element val);
void operator=(const TMatrixTSparseDiag_const<Element> &d);
TMatrixTSparseDiag<Element>& operator=(const TMatrixTSparseDiag <Element> &d) { operator=((TMatrixTSparseDiag_const<Element> &)d); return *this;}
void operator=(const TVectorT <Element> &vec);
void operator+=(const TMatrixTSparseDiag_const<Element> &d);
void operator*=(const TMatrixTSparseDiag_const<Element> &d);
ClassDef(TMatrixTSparseDiag,0)
};
Double_t Drand(Double_t &ix);
#endif
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.