// @(#)root/matrix:$Id$
// Authors: Fons Rademakers, Eddy Offermann   Nov 2003

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TMatrixTUtils
#define ROOT_TMatrixTUtils

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Matrix utility classes.                                              //
//                                                                      //
// Templates of utility classes in the Linear Algebra Package.          //
// The following classes are defined here:                              //
//                                                                      //
// Different matrix views without copying data elements :               //
//   TMatrixTRow_const        TMatrixTRow                               //
//   TMatrixTColumn_const     TMatrixTColumn                            //
//   TMatrixTDiag_const       TMatrixTDiag                              //
//   TMatrixTFlat_const       TMatrixTFlat                              //
//   TMatrixTSub_const        TMatrixTSub                               //
//   TMatrixTSparseRow_const  TMatrixTSparseRow                         //
//   TMatrixTSparseDiag_const TMatrixTSparseDiag                        //
//                                                                      //
//   TElementActionT                                                    //
//   TElementPosActionT                                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#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;

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TElementActionT                                                      //
//                                                                      //
// A class to do a specific operation on every vector or matrix element //
// (regardless of it position) as the object is being traversed.        //
// This is an abstract class. Derived classes need to implement the     //
// action function Operation().                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

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;}
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TElementPosActionT                                                   //
//                                                                      //
// A class to do a specific operation on every vector or matrix element //
// as the object is being traversed. This is an abstract class.         //
// Derived classes need to implement the action function Operation().   //
// In the action function the location of the current element is        //
// known (fI=row, fJ=columns).                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

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; // i position of element being passed to Operation()
   mutable Int_t fJ; // j position of element being passed to Operation()
   virtual ~TElementPosActionT() { }
   virtual void Operation(Element &element) const = 0;

private:
   TElementPosActionT<Element>& operator=(const TElementPosActionT<Element> &) {return *this;}
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTRow_const                                                    //
//                                                                      //
// Template class represents a row of a TMatrixT/TMatrixTSym            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTRow_const {

protected:
   const TMatrixTBase<Element> *fMatrix;  //  the matrix I am a row of
         Int_t                  fRowInd;  //  effective row index
         Int_t                  fInc;     //  if ptr = @a[row,i], then ptr+inc = @a[row,i+1]
   const Element               *fPtr;     //  pointer to the a[row,0]

public:
   TMatrixTRow_const() { fMatrix = 0; fRowInd = 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) {
    if(this != &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 of General Matrix Row Access class
};

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 of General Matrix Row Access class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTColumn_const                                                 //
//                                                                      //
// Template class represents a column of a TMatrixT/TMatrixTSym         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTColumn_const {

protected:
   const TMatrixTBase<Element> *fMatrix;  //  the matrix I am a column of
         Int_t                  fColInd;  //  effective column index
         Int_t                  fInc;     //  if ptr = @a[i,col], then ptr+inc = @a[i+1,col]
   const Element               *fPtr;     //  pointer to the a[0,col] column

public:
   TMatrixTColumn_const() { fMatrix = 0; fColInd = 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) {
     if(this != &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 of General Matrix Column Access class
};

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();

      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 of General Matrix Column Access class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTDiag_const                                                   //
//                                                                      //
// Template class represents the diagonal of a TMatrixT/TMatrixTSym     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTDiag_const {

protected:
   const TMatrixTBase<Element> *fMatrix;  //  the matrix I am the diagonal of
         Int_t                  fInc;     //  if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]
         Int_t                  fNdiag;   //  number of diag elems, min(nrows,ncols)
   const Element               *fPtr;     //  pointer to the a[0,0]

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) {
      if(this != &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 of General Matrix Diagonal Access class
};

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 of General Matrix Diagonal Access class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTFlat_const                                                   //
//                                                                      //
// Template class represents a flat TMatrixT/TMatrixTSym                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTFlat_const {

protected:
   const TMatrixTBase<Element> *fMatrix;  //  the matrix I am the diagonal of
         Int_t                  fNelems;  //
   const Element               *fPtr;     //  pointer to the a[0,0]

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) {
      if(this != &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 of General Matrix Flat Representation class
};

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 of General Matrix Flat Representation class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSub_const                                                    //
//                                                                      //
// Template class represents a sub matrix of TMatrixT/TMatrixTSym       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTSub_const {

protected:
   const TMatrixTBase<Element> *fMatrix;    //  the matrix I am a submatrix of
         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 of Sub Matrix Access class
};

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 of Sub Matrix Access class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSparseRow_const                                              //
//                                                                      //
// Template class represents a row of TMatrixTSparse                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTSparseRow_const {

protected:
   const TMatrixTSparse<Element> *fMatrix;  // the matrix I am a row of
         Int_t                  fRowInd;  // effective row index
         Int_t                  fNindex;  // index range
   const Int_t                 *fColPtr;  // column index pointer
   const Element               *fDataPtr; // data pointer

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) {
     if(this != &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; }

          Element operator()(Int_t i) const;
   inline Element operator[](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }

   ClassDef(TMatrixTSparseRow_const,0)  // Template of Sparse Matrix Row Access class
};

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); }

          Element  operator()(Int_t i) const;
          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 of Sparse Matrix Row Access class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSparseDiag_const                                             //
//                                                                      //
// Template class represents the diagonal of TMatrixTSparse             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTSparseDiag_const {

protected:
   const TMatrixTSparse<Element> *fMatrix;  //  the matrix I am the diagonal of
         Int_t                  fNdiag;   //  number of diag elems, min(nrows,ncols)
   const Element               *fDataPtr; //  data pointer

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) {
      if(this !=  &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; }

          Element operator ()(Int_t i) const;
   inline Element operator [](Int_t i) const { return (*(const TMatrixTSparseRow_const<Element> *)this)(i); }

   ClassDef(TMatrixTSparseDiag_const,0)  // Template of Sparse Matrix Diagonal Access class
};

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); }

                Element  operator()(Int_t i) const;
                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)  // Template of Sparse Matrix Diagonal Access class
};

Double_t Drand(Double_t &ix);
#endif
 TMatrixTUtils.h:1
 TMatrixTUtils.h:2
 TMatrixTUtils.h:3
 TMatrixTUtils.h:4
 TMatrixTUtils.h:5
 TMatrixTUtils.h:6
 TMatrixTUtils.h:7
 TMatrixTUtils.h:8
 TMatrixTUtils.h:9
 TMatrixTUtils.h:10
 TMatrixTUtils.h:11
 TMatrixTUtils.h:12
 TMatrixTUtils.h:13
 TMatrixTUtils.h:14
 TMatrixTUtils.h:15
 TMatrixTUtils.h:16
 TMatrixTUtils.h:17
 TMatrixTUtils.h:18
 TMatrixTUtils.h:19
 TMatrixTUtils.h:20
 TMatrixTUtils.h:21
 TMatrixTUtils.h:22
 TMatrixTUtils.h:23
 TMatrixTUtils.h:24
 TMatrixTUtils.h:25
 TMatrixTUtils.h:26
 TMatrixTUtils.h:27
 TMatrixTUtils.h:28
 TMatrixTUtils.h:29
 TMatrixTUtils.h:30
 TMatrixTUtils.h:31
 TMatrixTUtils.h:32
 TMatrixTUtils.h:33
 TMatrixTUtils.h:34
 TMatrixTUtils.h:35
 TMatrixTUtils.h:36
 TMatrixTUtils.h:37
 TMatrixTUtils.h:38
 TMatrixTUtils.h:39
 TMatrixTUtils.h:40
 TMatrixTUtils.h:41
 TMatrixTUtils.h:42
 TMatrixTUtils.h:43
 TMatrixTUtils.h:44
 TMatrixTUtils.h:45
 TMatrixTUtils.h:46
 TMatrixTUtils.h:47
 TMatrixTUtils.h:48
 TMatrixTUtils.h:49
 TMatrixTUtils.h:50
 TMatrixTUtils.h:51
 TMatrixTUtils.h:52
 TMatrixTUtils.h:53
 TMatrixTUtils.h:54
 TMatrixTUtils.h:55
 TMatrixTUtils.h:56
 TMatrixTUtils.h:57
 TMatrixTUtils.h:58
 TMatrixTUtils.h:59
 TMatrixTUtils.h:60
 TMatrixTUtils.h:61
 TMatrixTUtils.h:62
 TMatrixTUtils.h:63
 TMatrixTUtils.h:64
 TMatrixTUtils.h:65
 TMatrixTUtils.h:66
 TMatrixTUtils.h:67
 TMatrixTUtils.h:68
 TMatrixTUtils.h:69
 TMatrixTUtils.h:70
 TMatrixTUtils.h:71
 TMatrixTUtils.h:72
 TMatrixTUtils.h:73
 TMatrixTUtils.h:74
 TMatrixTUtils.h:75
 TMatrixTUtils.h:76
 TMatrixTUtils.h:77
 TMatrixTUtils.h:78
 TMatrixTUtils.h:79
 TMatrixTUtils.h:80
 TMatrixTUtils.h:81
 TMatrixTUtils.h:82
 TMatrixTUtils.h:83
 TMatrixTUtils.h:84
 TMatrixTUtils.h:85
 TMatrixTUtils.h:86
 TMatrixTUtils.h:87
 TMatrixTUtils.h:88
 TMatrixTUtils.h:89
 TMatrixTUtils.h:90
 TMatrixTUtils.h:91
 TMatrixTUtils.h:92
 TMatrixTUtils.h:93
 TMatrixTUtils.h:94
 TMatrixTUtils.h:95
 TMatrixTUtils.h:96
 TMatrixTUtils.h:97
 TMatrixTUtils.h:98
 TMatrixTUtils.h:99
 TMatrixTUtils.h:100
 TMatrixTUtils.h:101
 TMatrixTUtils.h:102
 TMatrixTUtils.h:103
 TMatrixTUtils.h:104
 TMatrixTUtils.h:105
 TMatrixTUtils.h:106
 TMatrixTUtils.h:107
 TMatrixTUtils.h:108
 TMatrixTUtils.h:109
 TMatrixTUtils.h:110
 TMatrixTUtils.h:111
 TMatrixTUtils.h:112
 TMatrixTUtils.h:113
 TMatrixTUtils.h:114
 TMatrixTUtils.h:115
 TMatrixTUtils.h:116
 TMatrixTUtils.h:117
 TMatrixTUtils.h:118
 TMatrixTUtils.h:119
 TMatrixTUtils.h:120
 TMatrixTUtils.h:121
 TMatrixTUtils.h:122
 TMatrixTUtils.h:123
 TMatrixTUtils.h:124
 TMatrixTUtils.h:125
 TMatrixTUtils.h:126
 TMatrixTUtils.h:127
 TMatrixTUtils.h:128
 TMatrixTUtils.h:129
 TMatrixTUtils.h:130
 TMatrixTUtils.h:131
 TMatrixTUtils.h:132
 TMatrixTUtils.h:133
 TMatrixTUtils.h:134
 TMatrixTUtils.h:135
 TMatrixTUtils.h:136
 TMatrixTUtils.h:137
 TMatrixTUtils.h:138
 TMatrixTUtils.h:139
 TMatrixTUtils.h:140
 TMatrixTUtils.h:141
 TMatrixTUtils.h:142
 TMatrixTUtils.h:143
 TMatrixTUtils.h:144
 TMatrixTUtils.h:145
 TMatrixTUtils.h:146
 TMatrixTUtils.h:147
 TMatrixTUtils.h:148
 TMatrixTUtils.h:149
 TMatrixTUtils.h:150
 TMatrixTUtils.h:151
 TMatrixTUtils.h:152
 TMatrixTUtils.h:153
 TMatrixTUtils.h:154
 TMatrixTUtils.h:155
 TMatrixTUtils.h:156
 TMatrixTUtils.h:157
 TMatrixTUtils.h:158
 TMatrixTUtils.h:159
 TMatrixTUtils.h:160
 TMatrixTUtils.h:161
 TMatrixTUtils.h:162
 TMatrixTUtils.h:163
 TMatrixTUtils.h:164
 TMatrixTUtils.h:165
 TMatrixTUtils.h:166
 TMatrixTUtils.h:167
 TMatrixTUtils.h:168
 TMatrixTUtils.h:169
 TMatrixTUtils.h:170
 TMatrixTUtils.h:171
 TMatrixTUtils.h:172
 TMatrixTUtils.h:173
 TMatrixTUtils.h:174
 TMatrixTUtils.h:175
 TMatrixTUtils.h:176
 TMatrixTUtils.h:177
 TMatrixTUtils.h:178
 TMatrixTUtils.h:179
 TMatrixTUtils.h:180
 TMatrixTUtils.h:181
 TMatrixTUtils.h:182
 TMatrixTUtils.h:183
 TMatrixTUtils.h:184
 TMatrixTUtils.h:185
 TMatrixTUtils.h:186
 TMatrixTUtils.h:187
 TMatrixTUtils.h:188
 TMatrixTUtils.h:189
 TMatrixTUtils.h:190
 TMatrixTUtils.h:191
 TMatrixTUtils.h:192
 TMatrixTUtils.h:193
 TMatrixTUtils.h:194
 TMatrixTUtils.h:195
 TMatrixTUtils.h:196
 TMatrixTUtils.h:197
 TMatrixTUtils.h:198
 TMatrixTUtils.h:199
 TMatrixTUtils.h:200
 TMatrixTUtils.h:201
 TMatrixTUtils.h:202
 TMatrixTUtils.h:203
 TMatrixTUtils.h:204
 TMatrixTUtils.h:205
 TMatrixTUtils.h:206
 TMatrixTUtils.h:207
 TMatrixTUtils.h:208
 TMatrixTUtils.h:209
 TMatrixTUtils.h:210
 TMatrixTUtils.h:211
 TMatrixTUtils.h:212
 TMatrixTUtils.h:213
 TMatrixTUtils.h:214
 TMatrixTUtils.h:215
 TMatrixTUtils.h:216
 TMatrixTUtils.h:217
 TMatrixTUtils.h:218
 TMatrixTUtils.h:219
 TMatrixTUtils.h:220
 TMatrixTUtils.h:221
 TMatrixTUtils.h:222
 TMatrixTUtils.h:223
 TMatrixTUtils.h:224
 TMatrixTUtils.h:225
 TMatrixTUtils.h:226
 TMatrixTUtils.h:227
 TMatrixTUtils.h:228
 TMatrixTUtils.h:229
 TMatrixTUtils.h:230
 TMatrixTUtils.h:231
 TMatrixTUtils.h:232
 TMatrixTUtils.h:233
 TMatrixTUtils.h:234
 TMatrixTUtils.h:235
 TMatrixTUtils.h:236
 TMatrixTUtils.h:237
 TMatrixTUtils.h:238
 TMatrixTUtils.h:239
 TMatrixTUtils.h:240
 TMatrixTUtils.h:241
 TMatrixTUtils.h:242
 TMatrixTUtils.h:243
 TMatrixTUtils.h:244
 TMatrixTUtils.h:245
 TMatrixTUtils.h:246
 TMatrixTUtils.h:247
 TMatrixTUtils.h:248
 TMatrixTUtils.h:249
 TMatrixTUtils.h:250
 TMatrixTUtils.h:251
 TMatrixTUtils.h:252
 TMatrixTUtils.h:253
 TMatrixTUtils.h:254
 TMatrixTUtils.h:255
 TMatrixTUtils.h:256
 TMatrixTUtils.h:257
 TMatrixTUtils.h:258
 TMatrixTUtils.h:259
 TMatrixTUtils.h:260
 TMatrixTUtils.h:261
 TMatrixTUtils.h:262
 TMatrixTUtils.h:263
 TMatrixTUtils.h:264
 TMatrixTUtils.h:265
 TMatrixTUtils.h:266
 TMatrixTUtils.h:267
 TMatrixTUtils.h:268
 TMatrixTUtils.h:269
 TMatrixTUtils.h:270
 TMatrixTUtils.h:271
 TMatrixTUtils.h:272
 TMatrixTUtils.h:273
 TMatrixTUtils.h:274
 TMatrixTUtils.h:275
 TMatrixTUtils.h:276
 TMatrixTUtils.h:277
 TMatrixTUtils.h:278
 TMatrixTUtils.h:279
 TMatrixTUtils.h:280
 TMatrixTUtils.h:281
 TMatrixTUtils.h:282
 TMatrixTUtils.h:283
 TMatrixTUtils.h:284
 TMatrixTUtils.h:285
 TMatrixTUtils.h:286
 TMatrixTUtils.h:287
 TMatrixTUtils.h:288
 TMatrixTUtils.h:289
 TMatrixTUtils.h:290
 TMatrixTUtils.h:291
 TMatrixTUtils.h:292
 TMatrixTUtils.h:293
 TMatrixTUtils.h:294
 TMatrixTUtils.h:295
 TMatrixTUtils.h:296
 TMatrixTUtils.h:297
 TMatrixTUtils.h:298
 TMatrixTUtils.h:299
 TMatrixTUtils.h:300
 TMatrixTUtils.h:301
 TMatrixTUtils.h:302
 TMatrixTUtils.h:303
 TMatrixTUtils.h:304
 TMatrixTUtils.h:305
 TMatrixTUtils.h:306
 TMatrixTUtils.h:307
 TMatrixTUtils.h:308
 TMatrixTUtils.h:309
 TMatrixTUtils.h:310
 TMatrixTUtils.h:311
 TMatrixTUtils.h:312
 TMatrixTUtils.h:313
 TMatrixTUtils.h:314
 TMatrixTUtils.h:315
 TMatrixTUtils.h:316
 TMatrixTUtils.h:317
 TMatrixTUtils.h:318
 TMatrixTUtils.h:319
 TMatrixTUtils.h:320
 TMatrixTUtils.h:321
 TMatrixTUtils.h:322
 TMatrixTUtils.h:323
 TMatrixTUtils.h:324
 TMatrixTUtils.h:325
 TMatrixTUtils.h:326
 TMatrixTUtils.h:327
 TMatrixTUtils.h:328
 TMatrixTUtils.h:329
 TMatrixTUtils.h:330
 TMatrixTUtils.h:331
 TMatrixTUtils.h:332
 TMatrixTUtils.h:333
 TMatrixTUtils.h:334
 TMatrixTUtils.h:335
 TMatrixTUtils.h:336
 TMatrixTUtils.h:337
 TMatrixTUtils.h:338
 TMatrixTUtils.h:339
 TMatrixTUtils.h:340
 TMatrixTUtils.h:341
 TMatrixTUtils.h:342
 TMatrixTUtils.h:343
 TMatrixTUtils.h:344
 TMatrixTUtils.h:345
 TMatrixTUtils.h:346
 TMatrixTUtils.h:347
 TMatrixTUtils.h:348
 TMatrixTUtils.h:349
 TMatrixTUtils.h:350
 TMatrixTUtils.h:351
 TMatrixTUtils.h:352
 TMatrixTUtils.h:353
 TMatrixTUtils.h:354
 TMatrixTUtils.h:355
 TMatrixTUtils.h:356
 TMatrixTUtils.h:357
 TMatrixTUtils.h:358
 TMatrixTUtils.h:359
 TMatrixTUtils.h:360
 TMatrixTUtils.h:361
 TMatrixTUtils.h:362
 TMatrixTUtils.h:363
 TMatrixTUtils.h:364
 TMatrixTUtils.h:365
 TMatrixTUtils.h:366
 TMatrixTUtils.h:367
 TMatrixTUtils.h:368
 TMatrixTUtils.h:369
 TMatrixTUtils.h:370
 TMatrixTUtils.h:371
 TMatrixTUtils.h:372
 TMatrixTUtils.h:373
 TMatrixTUtils.h:374
 TMatrixTUtils.h:375
 TMatrixTUtils.h:376
 TMatrixTUtils.h:377
 TMatrixTUtils.h:378
 TMatrixTUtils.h:379
 TMatrixTUtils.h:380
 TMatrixTUtils.h:381
 TMatrixTUtils.h:382
 TMatrixTUtils.h:383
 TMatrixTUtils.h:384
 TMatrixTUtils.h:385
 TMatrixTUtils.h:386
 TMatrixTUtils.h:387
 TMatrixTUtils.h:388
 TMatrixTUtils.h:389
 TMatrixTUtils.h:390
 TMatrixTUtils.h:391
 TMatrixTUtils.h:392
 TMatrixTUtils.h:393
 TMatrixTUtils.h:394
 TMatrixTUtils.h:395
 TMatrixTUtils.h:396
 TMatrixTUtils.h:397
 TMatrixTUtils.h:398
 TMatrixTUtils.h:399
 TMatrixTUtils.h:400
 TMatrixTUtils.h:401
 TMatrixTUtils.h:402
 TMatrixTUtils.h:403
 TMatrixTUtils.h:404
 TMatrixTUtils.h:405
 TMatrixTUtils.h:406
 TMatrixTUtils.h:407
 TMatrixTUtils.h:408
 TMatrixTUtils.h:409
 TMatrixTUtils.h:410
 TMatrixTUtils.h:411
 TMatrixTUtils.h:412
 TMatrixTUtils.h:413
 TMatrixTUtils.h:414
 TMatrixTUtils.h:415
 TMatrixTUtils.h:416
 TMatrixTUtils.h:417
 TMatrixTUtils.h:418
 TMatrixTUtils.h:419
 TMatrixTUtils.h:420
 TMatrixTUtils.h:421
 TMatrixTUtils.h:422
 TMatrixTUtils.h:423
 TMatrixTUtils.h:424
 TMatrixTUtils.h:425
 TMatrixTUtils.h:426
 TMatrixTUtils.h:427
 TMatrixTUtils.h:428
 TMatrixTUtils.h:429
 TMatrixTUtils.h:430
 TMatrixTUtils.h:431
 TMatrixTUtils.h:432
 TMatrixTUtils.h:433
 TMatrixTUtils.h:434
 TMatrixTUtils.h:435
 TMatrixTUtils.h:436
 TMatrixTUtils.h:437
 TMatrixTUtils.h:438
 TMatrixTUtils.h:439
 TMatrixTUtils.h:440
 TMatrixTUtils.h:441
 TMatrixTUtils.h:442
 TMatrixTUtils.h:443
 TMatrixTUtils.h:444
 TMatrixTUtils.h:445
 TMatrixTUtils.h:446
 TMatrixTUtils.h:447
 TMatrixTUtils.h:448
 TMatrixTUtils.h:449
 TMatrixTUtils.h:450
 TMatrixTUtils.h:451
 TMatrixTUtils.h:452
 TMatrixTUtils.h:453
 TMatrixTUtils.h:454
 TMatrixTUtils.h:455
 TMatrixTUtils.h:456
 TMatrixTUtils.h:457
 TMatrixTUtils.h:458
 TMatrixTUtils.h:459
 TMatrixTUtils.h:460
 TMatrixTUtils.h:461
 TMatrixTUtils.h:462
 TMatrixTUtils.h:463
 TMatrixTUtils.h:464
 TMatrixTUtils.h:465
 TMatrixTUtils.h:466
 TMatrixTUtils.h:467
 TMatrixTUtils.h:468
 TMatrixTUtils.h:469
 TMatrixTUtils.h:470
 TMatrixTUtils.h:471
 TMatrixTUtils.h:472
 TMatrixTUtils.h:473
 TMatrixTUtils.h:474
 TMatrixTUtils.h:475
 TMatrixTUtils.h:476
 TMatrixTUtils.h:477
 TMatrixTUtils.h:478
 TMatrixTUtils.h:479
 TMatrixTUtils.h:480
 TMatrixTUtils.h:481
 TMatrixTUtils.h:482
 TMatrixTUtils.h:483
 TMatrixTUtils.h:484
 TMatrixTUtils.h:485
 TMatrixTUtils.h:486
 TMatrixTUtils.h:487
 TMatrixTUtils.h:488
 TMatrixTUtils.h:489
 TMatrixTUtils.h:490
 TMatrixTUtils.h:491
 TMatrixTUtils.h:492
 TMatrixTUtils.h:493
 TMatrixTUtils.h:494
 TMatrixTUtils.h:495
 TMatrixTUtils.h:496
 TMatrixTUtils.h:497
 TMatrixTUtils.h:498
 TMatrixTUtils.h:499
 TMatrixTUtils.h:500
 TMatrixTUtils.h:501
 TMatrixTUtils.h:502
 TMatrixTUtils.h:503
 TMatrixTUtils.h:504
 TMatrixTUtils.h:505
 TMatrixTUtils.h:506
 TMatrixTUtils.h:507
 TMatrixTUtils.h:508
 TMatrixTUtils.h:509
 TMatrixTUtils.h:510
 TMatrixTUtils.h:511
 TMatrixTUtils.h:512
 TMatrixTUtils.h:513
 TMatrixTUtils.h:514
 TMatrixTUtils.h:515
 TMatrixTUtils.h:516
 TMatrixTUtils.h:517
 TMatrixTUtils.h:518
 TMatrixTUtils.h:519
 TMatrixTUtils.h:520
 TMatrixTUtils.h:521
 TMatrixTUtils.h:522
 TMatrixTUtils.h:523
 TMatrixTUtils.h:524
 TMatrixTUtils.h:525
 TMatrixTUtils.h:526
 TMatrixTUtils.h:527
 TMatrixTUtils.h:528
 TMatrixTUtils.h:529
 TMatrixTUtils.h:530
 TMatrixTUtils.h:531
 TMatrixTUtils.h:532
 TMatrixTUtils.h:533
 TMatrixTUtils.h:534
 TMatrixTUtils.h:535
 TMatrixTUtils.h:536
 TMatrixTUtils.h:537
 TMatrixTUtils.h:538
 TMatrixTUtils.h:539
 TMatrixTUtils.h:540
 TMatrixTUtils.h:541
 TMatrixTUtils.h:542
 TMatrixTUtils.h:543
 TMatrixTUtils.h:544
 TMatrixTUtils.h:545
 TMatrixTUtils.h:546
 TMatrixTUtils.h:547
 TMatrixTUtils.h:548
 TMatrixTUtils.h:549
 TMatrixTUtils.h:550
 TMatrixTUtils.h:551
 TMatrixTUtils.h:552
 TMatrixTUtils.h:553
 TMatrixTUtils.h:554
 TMatrixTUtils.h:555
 TMatrixTUtils.h:556
 TMatrixTUtils.h:557
 TMatrixTUtils.h:558
 TMatrixTUtils.h:559
 TMatrixTUtils.h:560
 TMatrixTUtils.h:561
 TMatrixTUtils.h:562
 TMatrixTUtils.h:563
 TMatrixTUtils.h:564
 TMatrixTUtils.h:565
 TMatrixTUtils.h:566
 TMatrixTUtils.h:567
 TMatrixTUtils.h:568
 TMatrixTUtils.h:569
 TMatrixTUtils.h:570
 TMatrixTUtils.h:571
 TMatrixTUtils.h:572
 TMatrixTUtils.h:573
 TMatrixTUtils.h:574
 TMatrixTUtils.h:575
 TMatrixTUtils.h:576
 TMatrixTUtils.h:577
 TMatrixTUtils.h:578
 TMatrixTUtils.h:579
 TMatrixTUtils.h:580
 TMatrixTUtils.h:581
 TMatrixTUtils.h:582
 TMatrixTUtils.h:583
 TMatrixTUtils.h:584
 TMatrixTUtils.h:585
 TMatrixTUtils.h:586
 TMatrixTUtils.h:587
 TMatrixTUtils.h:588
 TMatrixTUtils.h:589
 TMatrixTUtils.h:590
 TMatrixTUtils.h:591
 TMatrixTUtils.h:592
 TMatrixTUtils.h:593
 TMatrixTUtils.h:594
 TMatrixTUtils.h:595
 TMatrixTUtils.h:596
 TMatrixTUtils.h:597
 TMatrixTUtils.h:598
 TMatrixTUtils.h:599
 TMatrixTUtils.h:600
 TMatrixTUtils.h:601
 TMatrixTUtils.h:602
 TMatrixTUtils.h:603
 TMatrixTUtils.h:604
 TMatrixTUtils.h:605
 TMatrixTUtils.h:606
 TMatrixTUtils.h:607
 TMatrixTUtils.h:608
 TMatrixTUtils.h:609
 TMatrixTUtils.h:610
 TMatrixTUtils.h:611
 TMatrixTUtils.h:612
 TMatrixTUtils.h:613
 TMatrixTUtils.h:614
 TMatrixTUtils.h:615
 TMatrixTUtils.h:616
 TMatrixTUtils.h:617
 TMatrixTUtils.h:618
 TMatrixTUtils.h:619
 TMatrixTUtils.h:620
 TMatrixTUtils.h:621
 TMatrixTUtils.h:622
 TMatrixTUtils.h:623
 TMatrixTUtils.h:624
 TMatrixTUtils.h:625
 TMatrixTUtils.h:626
 TMatrixTUtils.h:627
 TMatrixTUtils.h:628
 TMatrixTUtils.h:629
 TMatrixTUtils.h:630
 TMatrixTUtils.h:631
 TMatrixTUtils.h:632
 TMatrixTUtils.h:633
 TMatrixTUtils.h:634
 TMatrixTUtils.h:635
 TMatrixTUtils.h:636
 TMatrixTUtils.h:637
 TMatrixTUtils.h:638
 TMatrixTUtils.h:639
 TMatrixTUtils.h:640
 TMatrixTUtils.h:641
 TMatrixTUtils.h:642
 TMatrixTUtils.h:643
 TMatrixTUtils.h:644
 TMatrixTUtils.h:645
 TMatrixTUtils.h:646
 TMatrixTUtils.h:647
 TMatrixTUtils.h:648
 TMatrixTUtils.h:649
 TMatrixTUtils.h:650
 TMatrixTUtils.h:651
 TMatrixTUtils.h:652
 TMatrixTUtils.h:653
 TMatrixTUtils.h:654
 TMatrixTUtils.h:655
 TMatrixTUtils.h:656
 TMatrixTUtils.h:657
 TMatrixTUtils.h:658
 TMatrixTUtils.h:659
 TMatrixTUtils.h:660
 TMatrixTUtils.h:661
 TMatrixTUtils.h:662
 TMatrixTUtils.h:663
 TMatrixTUtils.h:664
 TMatrixTUtils.h:665
 TMatrixTUtils.h:666
 TMatrixTUtils.h:667
 TMatrixTUtils.h:668
 TMatrixTUtils.h:669
 TMatrixTUtils.h:670
 TMatrixTUtils.h:671
 TMatrixTUtils.h:672
 TMatrixTUtils.h:673
 TMatrixTUtils.h:674
 TMatrixTUtils.h:675
 TMatrixTUtils.h:676
 TMatrixTUtils.h:677
 TMatrixTUtils.h:678
 TMatrixTUtils.h:679
 TMatrixTUtils.h:680
 TMatrixTUtils.h:681
 TMatrixTUtils.h:682
 TMatrixTUtils.h:683
 TMatrixTUtils.h:684
 TMatrixTUtils.h:685
 TMatrixTUtils.h:686
 TMatrixTUtils.h:687
 TMatrixTUtils.h:688
 TMatrixTUtils.h:689
 TMatrixTUtils.h:690
 TMatrixTUtils.h:691
 TMatrixTUtils.h:692
 TMatrixTUtils.h:693
 TMatrixTUtils.h:694
 TMatrixTUtils.h:695