// @(#)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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// 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                                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMatrixTUtils.h"
#include "TMatrixT.h"
#include "TMatrixTSym.h"
#include "TMatrixTSparse.h"
#include "TMath.h"
#include "TVectorT.h"

//______________________________________________________________________________
template<class Element>
TMatrixTRow_const<Element>::TMatrixTRow_const(const TMatrixT<Element> &matrix,Int_t row)
{
// Constructor with row "row" of matrix

   R__ASSERT(matrix.IsValid());

   fRowInd = row-matrix.GetRowLwb();
   if (fRowInd >= matrix.GetNrows() || fRowInd < 0) {
      Error("TMatrixTRow_const(const TMatrixT<Element> &,Int_t)","row index out of bounds");
      fMatrix = 0;
      fPtr = 0;
      fInc = 0;
      return;
   }

   fMatrix = &matrix;
   fPtr = matrix.GetMatrixArray()+fRowInd*matrix.GetNcols();
   fInc = 1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTRow_const<Element>::TMatrixTRow_const(const TMatrixTSym<Element> &matrix,Int_t row)
{
// Constructor with row "row" of symmetric matrix

   R__ASSERT(matrix.IsValid());

   fRowInd = row-matrix.GetRowLwb();
   if (fRowInd >= matrix.GetNrows() || fRowInd < 0) {
      Error("TMatrixTRow_const(const TMatrixTSym &,Int_t)","row index out of bounds");
      fMatrix = 0;
      fPtr = 0;
      fInc = 0;
      return;
   }

   fMatrix = &matrix;
   fPtr = matrix.GetMatrixArray()+fRowInd*matrix.GetNcols();
   fInc = 1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTRow<Element>::TMatrixTRow(TMatrixT<Element> &matrix,Int_t row)
            :TMatrixTRow_const<Element>(matrix,row)
{
// Constructor with row "row" of symmetric matrix
}

//______________________________________________________________________________
template<class Element>
TMatrixTRow<Element>::TMatrixTRow(TMatrixTSym<Element> &matrix,Int_t row)
            :TMatrixTRow_const<Element>(matrix,row)
{
// Constructor with row "row" of symmetric matrix
}

//______________________________________________________________________________
template<class Element>
TMatrixTRow<Element>::TMatrixTRow(const TMatrixTRow<Element> &mr) : TMatrixTRow_const<Element>(mr)
{
// Copy constructor

   *this = mr;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator=(Element val)
{
// Assign val to every element of the matrix row.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fPtr);
   for ( ; rp < this->fPtr+this->fMatrix->GetNcols(); rp += this->fInc)
      *rp = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator+=(Element val)
{
// Add val to every element of the matrix row.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fPtr);
   for ( ; rp < this->fPtr+this->fMatrix->GetNcols(); rp += this->fInc)
      *rp += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator*=(Element val)
{
// Multiply every element of the matrix row with val.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fPtr);
   for ( ; rp < this->fPtr + this->fMatrix->GetNcols(); rp += this->fInc)
      *rp *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator=(const TMatrixTRow_const<Element> &mr)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = mr.GetMatrix();
   if (this->fMatrix->GetMatrixArray() == mt->GetMatrixArray() && this->fRowInd == mr.GetRowIndex()) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetNcols() != mt->GetNcols() || this->fMatrix->GetColLwb() != mt->GetColLwb()) {
      Error("operator=(const TMatrixTRow_const &)", "matrix rows not compatible");
      return;
   }

   Element *rp1 = const_cast<Element *>(this->fPtr);
   const Element *rp2 = mr.GetPtr();
   for ( ; rp1 < this->fPtr+this->fMatrix->GetNcols(); rp1 += this->fInc,rp2 += mr.GetInc())
      *rp1 = *rp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to a matrix row. The vector is considered row-vector
// to allow the assignment in the strict sense.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(vec.IsValid());

   if (this->fMatrix->GetColLwb() != vec.GetLwb() || this->fMatrix->GetNcols() != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != matrix-row length");
      return;
   }

   Element *rp = const_cast<Element *>(this->fPtr);
   const Element *vp = vec.GetMatrixArray();
   for ( ; rp < this->fPtr+this->fMatrix->GetNcols(); rp += this->fInc)
      *rp = *vp++;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator+=(const TMatrixTRow_const<Element> &r)
{
// Add to every element of the matrix row the corresponding element of row r.

  const TMatrixTBase<Element> *mt = r.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetColLwb() != mt->GetColLwb() || this->fMatrix->GetNcols() != mt->GetNcols()) {
      Error("operator+=(const TMatrixTRow_const &)","different row lengths");
      return;
   }

   Element *rp1 = const_cast<Element *>(this->fPtr);
   const Element *rp2 = r.GetPtr();
   for ( ; rp1 < this->fPtr+this->fMatrix->GetNcols(); rp1 += this->fInc,rp2 += r.GetInc())
     *rp1 += *rp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTRow<Element>::operator*=(const TMatrixTRow_const<Element> &r)
{
// Multiply every element of the matrix row with the
// corresponding element of row r.

   const TMatrixTBase<Element> *mt = r.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetColLwb() != mt->GetColLwb() || this->fMatrix->GetNcols() != mt->GetNcols()) {
      Error("operator*=(const TMatrixTRow_const &)","different row lengths");
      return;
   }

   Element *rp1 = const_cast<Element *>(this->fPtr);
   const Element *rp2 = r.GetPtr();
   for ( ; rp1 < this->fPtr+this->fMatrix->GetNcols(); rp1 += this->fInc,rp2 += r.GetInc())
      *rp1 *= *rp2;
}

//______________________________________________________________________________
template<class Element>
TMatrixTColumn_const<Element>::TMatrixTColumn_const(const TMatrixT<Element> &matrix,Int_t col)
{
// Constructor with column "col" of matrix

   R__ASSERT(matrix.IsValid());

   this->fColInd = col-matrix.GetColLwb();
   if (this->fColInd >= matrix.GetNcols() || this->fColInd < 0) {
      Error("TMatrixTColumn_const(const TMatrixT &,Int_t)","column index out of bounds");
      fMatrix = 0;
      fPtr = 0;
      fInc = 0;
      return;
   }

   fMatrix = &matrix;
   fPtr = matrix.GetMatrixArray()+fColInd;
   fInc = matrix.GetNcols();
}

//______________________________________________________________________________
template<class Element>
TMatrixTColumn_const<Element>::TMatrixTColumn_const(const TMatrixTSym<Element> &matrix,Int_t col)
{
// Constructor with column "col" of matrix

   R__ASSERT(matrix.IsValid());

   fColInd = col-matrix.GetColLwb();
   if (fColInd >= matrix.GetNcols() || fColInd < 0) {
      Error("TMatrixTColumn_const(const TMatrixTSym &,Int_t)","column index out of bounds");
      fMatrix = 0;
      fPtr = 0;
      fInc = 0;
      return;
   }

   fMatrix = &matrix;
   fPtr = matrix.GetMatrixArray()+fColInd;
   fInc = matrix.GetNcols();
}

//______________________________________________________________________________
template<class Element>
TMatrixTColumn<Element>::TMatrixTColumn(TMatrixT<Element> &matrix,Int_t col)
               :TMatrixTColumn_const<Element>(matrix,col)
{
// Constructor with column "col" of matrix
}

//______________________________________________________________________________
template<class Element>
TMatrixTColumn<Element>::TMatrixTColumn(TMatrixTSym<Element> &matrix,Int_t col)
               :TMatrixTColumn_const<Element>(matrix,col)
{
// Constructor with column "col" of matrix
}

//______________________________________________________________________________
template<class Element>
TMatrixTColumn<Element>::TMatrixTColumn(const TMatrixTColumn<Element> &mc) : TMatrixTColumn_const<Element>(mc)
{
// Copy constructor

   *this = mc;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator=(Element val)
{
// Assign val to every element of the matrix column.

   R__ASSERT(this->fMatrix->IsValid());
   Element *cp = const_cast<Element *>(this->fPtr);
   for ( ; cp < this->fPtr+this->fMatrix->GetNoElements(); cp += this->fInc)
      *cp = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator+=(Element val)
{
// Add val to every element of the matrix column.

   R__ASSERT(this->fMatrix->IsValid());
   Element *cp = const_cast<Element *>(this->fPtr);
   for ( ; cp < this->fPtr+this->fMatrix->GetNoElements(); cp += this->fInc)
      *cp += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator*=(Element val)
{
// Multiply every element of the matrix column with val.

   R__ASSERT(this->fMatrix->IsValid());
   Element *cp = const_cast<Element *>(this->fPtr);
   for ( ; cp < this->fPtr+this->fMatrix->GetNoElements(); cp += this->fInc)
      *cp *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator=(const TMatrixTColumn_const<Element> &mc)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = mc.GetMatrix();
   if (this->fMatrix->GetMatrixArray() == mt->GetMatrixArray() && this->fColInd == mc.GetColIndex()) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetNrows() != mt->GetNrows() || this->fMatrix->GetRowLwb() != mt->GetRowLwb()) {
      Error("operator=(const TMatrixTColumn_const &)", "matrix columns not compatible");
      return;
   }

   Element *cp1 = const_cast<Element *>(this->fPtr);
   const Element *cp2 = mc.GetPtr();
   for ( ; cp1 < this->fPtr+this->fMatrix->GetNoElements(); cp1 += this->fInc,cp2 += mc.GetInc())
      *cp1 = *cp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to a matrix column.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(vec.IsValid());

   if (this->fMatrix->GetRowLwb() != vec.GetLwb() || this->fMatrix->GetNrows() != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != matrix-column length");
      return;
   }

   Element *cp = const_cast<Element *>(this->fPtr);
   const Element *vp = vec.GetMatrixArray();
   for ( ; cp < this->fPtr+this->fMatrix->GetNoElements(); cp += this->fInc)
      *cp = *vp++;

   R__ASSERT(vp == vec.GetMatrixArray()+vec.GetNrows());
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator+=(const TMatrixTColumn_const<Element> &mc)
{
// Add to every element of the matrix row the corresponding element of row mc.

   const TMatrixTBase<Element> *mt = mc.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetRowLwb() != mt->GetRowLwb() || this->fMatrix->GetNrows() != mt->GetNrows()) {
      Error("operator+=(const TMatrixTColumn_const &)","different row lengths");
      return;
   }

   Element *cp1 = const_cast<Element *>(this->fPtr);
   const Element *cp2 = mc.GetPtr();
   for ( ; cp1 < this->fPtr+this->fMatrix->GetNoElements(); cp1 += this->fInc,cp2 += mc.GetInc())
      *cp1 += *cp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTColumn<Element>::operator*=(const TMatrixTColumn_const<Element> &mc)
{
// Multiply every element of the matrix column with the
// corresponding element of column mc.

   const TMatrixTBase<Element> *mt = mc.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix->GetRowLwb() != mt->GetRowLwb() || this->fMatrix->GetNrows() != mt->GetNrows()) {
      Error("operator*=(const TMatrixTColumn_const &)","different row lengths");
      return;
   }

   Element *cp1 = const_cast<Element *>(this->fPtr);
   const Element *cp2 = mc.GetPtr();
   for ( ; cp1 < this->fPtr+this->fMatrix->GetNoElements(); cp1 += this->fInc,cp2 += mc.GetInc())
      *cp1 *= *cp2;
}

//______________________________________________________________________________
template<class Element>
TMatrixTDiag_const<Element>::TMatrixTDiag_const(const TMatrixT<Element> &matrix)
{
// Constructor

   R__ASSERT(matrix.IsValid());

   fMatrix = &matrix;
   fNdiag  = TMath::Min(matrix.GetNrows(),matrix.GetNcols());
   fPtr    = matrix.GetMatrixArray();
   fInc    = matrix.GetNcols()+1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTDiag_const<Element>::TMatrixTDiag_const(const TMatrixTSym<Element> &matrix)
{
// Constructor

   R__ASSERT(matrix.IsValid());

   fMatrix = &matrix;
   fNdiag  = TMath::Min(matrix.GetNrows(),matrix.GetNcols());
   fPtr    = matrix.GetMatrixArray();
   fInc    = matrix.GetNcols()+1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTDiag<Element>::TMatrixTDiag(TMatrixT<Element> &matrix)
             :TMatrixTDiag_const<Element>(matrix)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTDiag<Element>::TMatrixTDiag(TMatrixTSym<Element> &matrix)
             :TMatrixTDiag_const<Element>(matrix)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTDiag<Element>::TMatrixTDiag(const TMatrixTDiag<Element> &md) : TMatrixTDiag_const<Element>(md)
{
// Copy constructor

   *this = md;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator=(Element val)
{
// Assign val to every element of the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   Element *dp = const_cast<Element *>(this->fPtr);
   for (Int_t i = 0; i < this->fNdiag; i++, dp += this->fInc)
      *dp = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator+=(Element val)
{
// Assign val to every element of the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   Element *dp = const_cast<Element *>(this->fPtr);
   for (Int_t i = 0; i < this->fNdiag; i++, dp += this->fInc)
      *dp += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator*=(Element val)
{
// Assign val to every element of the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   Element *dp = const_cast<Element *>(this->fPtr);
   for (Int_t i = 0; i < this->fNdiag; i++, dp += this->fInc)
      *dp *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator=(const TMatrixTDiag_const<Element> &md)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = md.GetMatrix();
   if (this->fMatrix == mt) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->GetNdiags() != md.GetNdiags()) {
      Error("operator=(const TMatrixTDiag_const &)","diagonals not compatible");
      return;
   }

   Element *dp1 = const_cast<Element *>(this->fPtr);
   const Element *dp2 = md.GetPtr();
   for (Int_t i = 0; i < this->fNdiag; i++, dp1 += this->fInc, dp2 += md.GetInc())
      *dp1 = *dp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(vec.IsValid());

   if (this->fNdiag != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != matrix-diagonal length");
      return;
   }

   Element *dp = const_cast<Element *>(this->fPtr);
   const Element *vp = vec.GetMatrixArray();
   for ( ; vp < vec.GetMatrixArray()+vec.GetNrows(); dp += this->fInc)
      *dp = *vp++;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator+=(const TMatrixTDiag_const<Element> &md)
{
// Add to every element of the matrix diagonal the
// corresponding element of diagonal md.

   const TMatrixTBase<Element> *mt = md.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fNdiag != md.GetNdiags()) {
      Error("operator=(const TMatrixTDiag_const &)","matrix-diagonal's different length");
      return;
   }

   Element *dp1 = const_cast<Element *>(this->fPtr);
   const Element *dp2 = md.GetPtr();
   for (Int_t i = 0; i < this->fNdiag; i++, dp1 += this->fInc, dp2 += md.GetInc())
      *dp1 += *dp2;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTDiag<Element>::operator*=(const TMatrixTDiag_const<Element> &md)
{
// Multiply every element of the matrix diagonal with the
// corresponding element of diagonal md.

   const TMatrixTBase<Element> *mt = md.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fNdiag != md.GetNdiags()) {
      Error("operator*=(const TMatrixTDiag_const &)","matrix-diagonal's different length");
      return;
   }

   Element *dp1 = const_cast<Element *>(this->fPtr);
   const Element *dp2 = md.GetPtr();
   for (Int_t i = 0; i < this->fNdiag; i++, dp1 += this->fInc, dp2 += md.GetInc())
      *dp1 *= *dp2;
}

//______________________________________________________________________________
template<class Element>
TMatrixTFlat_const<Element>::TMatrixTFlat_const(const TMatrixT<Element> &matrix)
{
// Constructor

   R__ASSERT(matrix.IsValid());

   fMatrix = &matrix;
   fPtr    = matrix.GetMatrixArray();
   fNelems = matrix.GetNoElements();
}

//______________________________________________________________________________
template<class Element>
TMatrixTFlat_const<Element>::TMatrixTFlat_const(const TMatrixTSym<Element> &matrix)
{
// Constructor

   R__ASSERT(matrix.IsValid());

   fMatrix = &matrix;
   fPtr    = matrix.GetMatrixArray();
   fNelems = matrix.GetNoElements();
}

//______________________________________________________________________________
template<class Element>
TMatrixTFlat<Element>::TMatrixTFlat(TMatrixT<Element> &matrix)
             :TMatrixTFlat_const<Element>(matrix)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTFlat<Element>::TMatrixTFlat(TMatrixTSym<Element> &matrix)
             :TMatrixTFlat_const<Element>(matrix)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTFlat<Element>::TMatrixTFlat(const TMatrixTFlat<Element> &mf) : TMatrixTFlat_const<Element>(mf)
{
// Copy constructor

   *this = mf;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator=(Element val)
{
// Assign val to every element of the matrix.

   R__ASSERT(this->fMatrix->IsValid());
   Element *fp = const_cast<Element *>(this->fPtr);
   while (fp < this->fPtr+this->fMatrix->GetNoElements())
      *fp++ = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator+=(Element val)
{
// Add val to every element of the matrix.

   R__ASSERT(this->fMatrix->IsValid());
   Element *fp = const_cast<Element *>(this->fPtr);
   while (fp < this->fPtr+this->fMatrix->GetNoElements())
      *fp++ += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator*=(Element val)
{
// Multiply every element of the matrix with val.

   R__ASSERT(this->fMatrix->IsValid());
   Element *fp = const_cast<Element *>(this->fPtr);
   while (fp < this->fPtr+this->fMatrix->GetNoElements())
      *fp++ *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator=(const TMatrixTFlat_const<Element> &mf)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = mf.GetMatrix();
   if (this->fMatrix->GetMatrixArray() == mt->GetMatrixArray()) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetNoElements() != mt->GetNoElements()) {
      Error("operator=(const TMatrixTFlat_const &)","matrix lengths different");
      return;
   }

   Element *fp1 = const_cast<Element *>(this->fPtr);
   const Element *fp2 = mf.GetPtr();
   while (fp1 < this->fPtr+this->fMatrix->GetNoElements())
      *fp1++ = *fp2++;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to the matrix. The matrix is traversed row-wise

   R__ASSERT(vec.IsValid());

   if (this->fMatrix->GetNoElements() != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != # matrix-elements");
      return;
   }

   Element *fp = const_cast<Element *>(this->fPtr);
   const Element *vp = vec.GetMatrixArray();
   while (fp < this->fPtr+this->fMatrix->GetNoElements())
       *fp++ = *vp++;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator+=(const TMatrixTFlat_const<Element> &mf)
{
// Add to every element of the matrix the corresponding element of matrix mf.

   const TMatrixTBase<Element> *mt = mf.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetNoElements() != mt->GetNoElements()) {
      Error("operator+=(const TMatrixTFlat_const &)","matrices lengths different");
      return;
   }

   Element *fp1 = const_cast<Element *>(this->fPtr);
   const Element *fp2 = mf.GetPtr();
   while (fp1 < this->fPtr + this->fMatrix->GetNoElements())
      *fp1++ += *fp2++;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTFlat<Element>::operator*=(const TMatrixTFlat_const<Element> &mf)
{
// Multiply every element of the matrix with the corresponding element of diagonal mf.

   const TMatrixTBase<Element> *mt = mf.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetNoElements() != mt->GetNoElements()) {
      Error("operator*=(const TMatrixTFlat_const &)","matrices lengths different");
      return;
   }

   Element *fp1 = const_cast<Element *>(this->fPtr);
   const Element *fp2 = mf.GetPtr();
   while (fp1 < this->fPtr + this->fMatrix->GetNoElements())
      *fp1++ *= *fp2++;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSub_const<Element>::TMatrixTSub_const(const TMatrixT<Element> &matrix,Int_t row_lwbs,Int_t row_upbs,
                                              Int_t col_lwbs,Int_t col_upbs)
{
// make a reference to submatrix [row_lwbs..row_upbs][col_lwbs..col_upbs];
// The indexing range of the reference is
// [0..row_upbs-row_lwbs+1][0..col_upb-col_lwbs+1] (default)

   R__ASSERT(matrix.IsValid());

   fRowOff    = 0;
   fColOff    = 0;
   fNrowsSub  = 0;
   fNcolsSub  = 0;
   fMatrix = &matrix;

   if (row_upbs < row_lwbs) {
      Error("TMatrixTSub_const","Request sub-matrix with row_upbs(%d) < row_lwbs(%d)",row_upbs,row_lwbs);
      return;
   }
   if (col_upbs < col_lwbs) {
      Error("TMatrixTSub_const","Request sub-matrix with col_upbs(%d) < col_lwbs(%d)",col_upbs,col_lwbs);
      return;
   }

   const Int_t rowLwb = matrix.GetRowLwb();
   const Int_t rowUpb = matrix.GetRowUpb();
   const Int_t colLwb = matrix.GetColLwb();
   const Int_t colUpb = matrix.GetColUpb();

   if (row_lwbs < rowLwb || row_lwbs > rowUpb) {
      Error("TMatrixTSub_const","Request row_lwbs sub-matrix(%d) outside matrix range of %d - %d",row_lwbs,rowLwb,rowUpb);
      return;
   }
   if (col_lwbs < colLwb || col_lwbs > colUpb) {
      Error("TMatrixTSub_const","Request col_lwbs sub-matrix(%d) outside matrix range of %d - %d",col_lwbs,colLwb,colUpb);
      return;
   }
   if (row_upbs < rowLwb || row_upbs > rowUpb) {
      Error("TMatrixTSub_const","Request row_upbs sub-matrix(%d) outside matrix range of %d - %d",row_upbs,rowLwb,rowUpb);
      return;
   }
   if (col_upbs < colLwb || col_upbs > colUpb) {
      Error("TMatrixTSub_const","Request col_upbs sub-matrix(%d) outside matrix range of %d - %d",col_upbs,colLwb,colUpb);
      return;
   }

   fRowOff    = row_lwbs-rowLwb;
   fColOff    = col_lwbs-colLwb;
   fNrowsSub  = row_upbs-row_lwbs+1;
   fNcolsSub  = col_upbs-col_lwbs+1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSub_const<Element>::TMatrixTSub_const(const TMatrixTSym<Element> &matrix,Int_t row_lwbs,Int_t row_upbs,
                                              Int_t col_lwbs,Int_t col_upbs)
{
// make a reference to submatrix [row_lwbs..row_upbs][col_lwbs..col_upbs];
// The indexing range of the reference is
// [0..row_upbs-row_lwbs+1][0..col_upb-col_lwbs+1] (default)

   R__ASSERT(matrix.IsValid());

   fRowOff    = 0;
   fColOff    = 0;
   fNrowsSub  = 0;
   fNcolsSub  = 0;
   fMatrix    = &matrix;

   if (row_upbs < row_lwbs) {
      Error("TMatrixTSub_const","Request sub-matrix with row_upbs(%d) < row_lwbs(%d)",row_upbs,row_lwbs);
      return;
   }
   if (col_upbs < col_lwbs) {
      Error("TMatrixTSub_const","Request sub-matrix with col_upbs(%d) < col_lwbs(%d)",col_upbs,col_lwbs);
      return;
   }

   const Int_t rowLwb = matrix.GetRowLwb();
   const Int_t rowUpb = matrix.GetRowUpb();
   const Int_t colLwb = matrix.GetColLwb();
   const Int_t colUpb = matrix.GetColUpb();

   if (row_lwbs < rowLwb || row_lwbs > rowUpb) {
      Error("TMatrixTSub_const","Request row_lwbs sub-matrix(%d) outside matrix range of %d - %d",row_lwbs,rowLwb,rowUpb);
      return;
   }
   if (col_lwbs < colLwb || col_lwbs > colUpb) {
      Error("TMatrixTSub_const","Request col_lwbs sub-matrix(%d) outside matrix range of %d - %d",col_lwbs,colLwb,colUpb);
      return;
   }
   if (row_upbs < rowLwb || row_upbs > rowUpb) {
      Error("TMatrixTSub_const","Request row_upbs sub-matrix(%d) outside matrix range of %d - %d",row_upbs,rowLwb,rowUpb);
      return;
   }
   if (col_upbs < colLwb || col_upbs > colUpb) {
      Error("TMatrixTSub_const","Request col_upbs sub-matrix(%d) outside matrix range of %d - %d",col_upbs,colLwb,colUpb);
      return;
   }

   fRowOff    = row_lwbs-rowLwb;
   fColOff    = col_lwbs-colLwb;
   fNrowsSub  = row_upbs-row_lwbs+1;
   fNcolsSub  = col_upbs-col_lwbs+1;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSub<Element>::TMatrixTSub(TMatrixT<Element> &matrix,Int_t row_lwbs,Int_t row_upbs,
                                  Int_t col_lwbs,Int_t col_upbs)
            :TMatrixTSub_const<Element>(matrix,row_lwbs,row_upbs,col_lwbs,col_upbs)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTSub<Element>::TMatrixTSub(TMatrixTSym<Element> &matrix,Int_t row_lwbs,Int_t row_upbs,
                                  Int_t col_lwbs,Int_t col_upbs)
            :TMatrixTSub_const<Element>(matrix,row_lwbs,row_upbs,col_lwbs,col_upbs)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTSub<Element>::TMatrixTSub(const TMatrixTSub<Element> &ms) : TMatrixTSub_const<Element>(ms)
{
// Copy constructor

   *this = ms;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::Rank1Update(const TVectorT<Element> &v,Element alpha)
{
// Perform a rank 1 operation on the matrix:
//     A += alpha * v * v^T

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(v.IsValid());

   if (v.GetNoElements() < TMath::Max(this->fNrowsSub,this->fNcolsSub)) {
      Error("Rank1Update","vector too short");
      return;
   }

   const Element * const pv = v.GetMatrixArray();
         Element *mp = (const_cast<TMatrixTBase<Element> *>(this->fMatrix))->GetMatrixArray();

   const Int_t ncols = this->fMatrix->GetNcols();
   for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
      const Int_t off = (irow+this->fRowOff)*ncols+this->fColOff;
      const Element tmp = alpha*pv[irow];
      for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
         mp[off+icol] += tmp*pv[icol];
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator=(Element val)
{
// Assign val to every element of the sub matrix.

   R__ASSERT(this->fMatrix->IsValid());

   Element *p = (const_cast<TMatrixTBase<Element> *>(this->fMatrix))->GetMatrixArray();
   const Int_t ncols = this->fMatrix->GetNcols();
   for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
      const Int_t off = (irow+this->fRowOff)*ncols+this->fColOff;
      for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
         p[off+icol] = val;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator+=(Element val)
{
// Add val to every element of the sub matrix.

   R__ASSERT(this->fMatrix->IsValid());

   Element *p = (const_cast<TMatrixTBase<Element> *>(this->fMatrix))->GetMatrixArray();
   const Int_t ncols = this->fMatrix->GetNcols();
   for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
      const Int_t off = (irow+this->fRowOff)*ncols+this->fColOff;
      for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
         p[off+icol] += val;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator*=(Element val)
{
// Multiply every element of the sub matrix by val .

   R__ASSERT(this->fMatrix->IsValid());

   Element *p = (const_cast<TMatrixTBase<Element> *>(this->fMatrix))->GetMatrixArray();
   const Int_t ncols = this->fMatrix->GetNcols();
   for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
      const Int_t off = (irow+this->fRowOff)*ncols+this->fColOff;
      for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
         p[off+icol] *= val;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator=(const TMatrixTSub_const<Element> &ms)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = ms.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->fMatrix == mt &&
       (this->GetNrows()  == ms.GetNrows () && this->GetNcols()  == ms.GetNcols () &&
        this->GetRowOff() == ms.GetRowOff() && this->GetColOff() == ms.GetColOff()) )
     return;

   if (this->GetNrows() != ms.GetNrows() || this->GetNcols() != ms.GetNcols()) {
     Error("operator=(const TMatrixTSub_const &)","sub matrices have different size");
      return;
   }

   const Int_t rowOff2 = ms.GetRowOff();
   const Int_t colOff2 = ms.GetColOff();

   Bool_t overlap = (this->fMatrix == mt) &&
                    ( (rowOff2 >= this->fRowOff && rowOff2 < this->fRowOff+this->fNrowsSub) ||
                      (colOff2 >= this->fColOff && colOff2 < this->fColOff+this->fNcolsSub) );

   Element *p1 = const_cast<Element *>(this->fMatrix->GetMatrixArray());
   if (!overlap) {
      const Element *p2 = mt->GetMatrixArray();

      const Int_t ncols1 = this->fMatrix->GetNcols();
      const Int_t ncols2 = mt->GetNcols();
      for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
         const Int_t off1 = (irow+this->fRowOff)*ncols1+this->fColOff;
         const Int_t off2 = (irow+rowOff2)*ncols2+colOff2;
         for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
            p1[off1+icol] = p2[off2+icol];
      }
   } else {
      const Int_t row_lwbs = rowOff2+mt->GetRowLwb();
      const Int_t row_upbs = row_lwbs+this->fNrowsSub-1;
      const Int_t col_lwbs = colOff2+mt->GetColLwb();
      const Int_t col_upbs = col_lwbs+this->fNcolsSub-1;
      TMatrixT<Element> tmp; mt->GetSub(row_lwbs,row_upbs,col_lwbs,col_upbs,tmp);
      const Element *p2 = tmp.GetMatrixArray();

      const Int_t ncols1 = this->fMatrix->GetNcols();
      const Int_t ncols2 = tmp.GetNcols();
      for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
         const Int_t off1 = (irow+this->fRowOff)*ncols1+this->fColOff;
         const Int_t off2 = irow*ncols2;
         for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
            p1[off1+icol] = p2[off2+icol];
      }
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator=(const TMatrixTBase<Element> &m)
{
// Assignment operator

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(m.IsValid());

   if (this->fMatrix->GetMatrixArray() == m.GetMatrixArray()) return;

   if (this->fNrowsSub != m.GetNrows() || this->fNcolsSub != m.GetNcols()) {
      Error("operator=(const TMatrixTBase<Element> &)","sub matrices and matrix have different size");
      return;
   }
   const Int_t row_lwbs = this->fRowOff+this->fMatrix->GetRowLwb();
   const Int_t col_lwbs = this->fColOff+this->fMatrix->GetColLwb();
   (const_cast<TMatrixTBase<Element> *>(this->fMatrix))->SetSub(row_lwbs,col_lwbs,m);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator+=(const TMatrixTSub_const<Element> &ms)
{
// Add to every element of the submatrix the corresponding element of submatrix ms.

   const TMatrixTBase<Element> *mt = ms.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());

   if (this->GetNrows() != ms.GetNrows() || this->GetNcols() != ms.GetNcols()) {
      Error("operator+=(const TMatrixTSub_const &)","sub matrices have different size");
      return;
   }

   const Int_t rowOff2 = ms.GetRowOff();
   const Int_t colOff2 = ms.GetColOff();

   Bool_t overlap = (this->fMatrix == mt) &&
                    ( (rowOff2 >= this->fRowOff && rowOff2 < this->fRowOff+this->fNrowsSub) ||
                      (colOff2 >= this->fColOff && colOff2 < this->fColOff+this->fNcolsSub) );

   Element *p1 = const_cast<Element *>(this->fMatrix->GetMatrixArray());
   if (!overlap) {
      const Element *p2 = mt->GetMatrixArray();

      const Int_t ncols1 = this->fMatrix->GetNcols();
      const Int_t ncols2 = mt->GetNcols();
      for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
         const Int_t off1 = (irow+this->fRowOff)*ncols1+this->fColOff;
         const Int_t off2 = (irow+rowOff2)*ncols2+colOff2;
         for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
            p1[off1+icol] += p2[off2+icol];
      }
   } else {
      const Int_t row_lwbs = rowOff2+mt->GetRowLwb();
      const Int_t row_upbs = row_lwbs+this->fNrowsSub-1;
      const Int_t col_lwbs = colOff2+mt->GetColLwb();
      const Int_t col_upbs = col_lwbs+this->fNcolsSub-1;
      TMatrixT<Element> tmp; mt->GetSub(row_lwbs,row_upbs,col_lwbs,col_upbs,tmp);
      const Element *p2 = tmp.GetMatrixArray();

      const Int_t ncols1 = this->fMatrix->GetNcols();
      const Int_t ncols2 = tmp.GetNcols();
      for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
         const Int_t off1 = (irow+this->fRowOff)*ncols1+this->fColOff;
         const Int_t off2 = irow*ncols2;
         for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
            p1[off1+icol] += p2[off2+icol];
      }
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator*=(const TMatrixTSub_const<Element> &ms)
{
// Multiply submatrix with submatrix ms.

   if (this->fNcolsSub != ms.GetNrows() || this->fNcolsSub != ms.GetNcols()) {
      Error("operator*=(const TMatrixTSub_const &)","source sub matrix has wrong shape");
      return;
   }

   const TMatrixTBase<Element> *source = ms.GetMatrix();

   TMatrixT<Element> source_sub;
   {
      const Int_t row_lwbs = ms.GetRowOff()+source->GetRowLwb();
      const Int_t row_upbs = row_lwbs+this->fNrowsSub-1;
      const Int_t col_lwbs = ms.GetColOff()+source->GetColLwb();
      const Int_t col_upbs = col_lwbs+this->fNcolsSub-1;
      source->GetSub(row_lwbs,row_upbs,col_lwbs,col_upbs,source_sub);
   }

   const Element *sp = source_sub.GetMatrixArray();
   const Int_t ncols = this->fMatrix->GetNcols();

   // One row of the old_target matrix
   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *trp = work;
   if (this->fNcolsSub > kWorkMax) {
      isAllocated = kTRUE;
      trp = new Element[this->fNcolsSub];
   }

         Element *cp   = const_cast<Element *>(this->fMatrix->GetMatrixArray())+this->fRowOff*ncols+this->fColOff;
   const Element *trp0 = cp; // Pointer to  target[i,0];
   const Element * const trp0_last = trp0+this->fNrowsSub*ncols;
   while (trp0 < trp0_last) {
      memcpy(trp,trp0,this->fNcolsSub*sizeof(Element));         // copy the i-th row of target, Start at target[i,0]
      for (const Element *scp = sp; scp < sp+this->fNcolsSub; ) {  // Pointer to the j-th column of source,
                                                                 // Start scp = source[0,0]
         Element cij = 0;
         for (Int_t j = 0; j < this->fNcolsSub; j++) {
            cij += trp[j] * *scp;                            // the j-th col of source
            scp += this->fNcolsSub;
         }
         *cp++ = cij;
         scp -= source_sub.GetNoElements()-1;               // Set bcp to the (j+1)-th col
      }
      cp   += ncols-this->fNcolsSub;
      trp0 += ncols;                                      // Set trp0 to the (i+1)-th row
      R__ASSERT(trp0 == cp);
   }

   R__ASSERT(cp == trp0_last && trp0 == trp0_last);
   if (isAllocated)
      delete [] trp;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator+=(const TMatrixTBase<Element> &mt)
{
// Add to every element of the submatrix the corresponding element of matrix mt.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt.IsValid());

   if (this->GetNrows() != mt.GetNrows() || this->GetNcols() != mt.GetNcols()) {
      Error("operator+=(const TMatrixTBase<Element> &)","sub matrix and matrix have different size");
      return;
   }

   Element *p1 = const_cast<Element *>(this->fMatrix->GetMatrixArray());
   const Element *p2 = mt.GetMatrixArray();

   const Int_t ncols1 = this->fMatrix->GetNcols();
   const Int_t ncols2 = mt.GetNcols();
   for (Int_t irow = 0; irow < this->fNrowsSub; irow++) {
      const Int_t off1 = (irow+this->fRowOff)*ncols1+this->fColOff;
      const Int_t off2 = irow*ncols2;
      for (Int_t icol = 0; icol < this->fNcolsSub; icol++)
         p1[off1+icol] += p2[off2+icol];
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator*=(const TMatrixT<Element> &source)
{
// Multiply submatrix with matrix source.

   if (this->fNcolsSub != source.GetNrows() || this->fNcolsSub != source.GetNcols()) {
      Error("operator*=(const TMatrixT<Element> &)","source matrix has wrong shape");
      return;
   }

   // Check for A *= A;
   const Element *sp;
   TMatrixT<Element> tmp;
   if (this->fMatrix->GetMatrixArray() == source.GetMatrixArray()) {
      tmp.ResizeTo(source);
      tmp = source;
      sp = tmp.GetMatrixArray();
   }
   else
      sp = source.GetMatrixArray();

   const Int_t ncols = this->fMatrix->GetNcols();

   // One row of the old_target matrix
   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
    Element *trp = work;
   if (this->fNcolsSub > kWorkMax) {
      isAllocated = kTRUE;
      trp = new Element[this->fNcolsSub];
   }

         Element *cp   = const_cast<Element *>(this->fMatrix->GetMatrixArray())+this->fRowOff*ncols+this->fColOff;
   const Element *trp0 = cp;                               // Pointer to  target[i,0];
   const Element * const trp0_last = trp0+this->fNrowsSub*ncols;
   while (trp0 < trp0_last) {
      memcpy(trp,trp0,this->fNcolsSub*sizeof(Element));           // copy the i-th row of target, Start at target[i,0]
      for (const Element *scp = sp; scp < sp+this->fNcolsSub; ) { // Pointer to the j-th column of source,
                                                                  // Start scp = source[0,0]
         Element cij = 0;
         for (Int_t j = 0; j < this->fNcolsSub; j++) {
            cij += trp[j] * *scp;                              // the j-th col of source
            scp += this->fNcolsSub;
         }
         *cp++ = cij;
         scp -= source.GetNoElements()-1;                    // Set bcp to the (j+1)-th col
      }
      cp   += ncols-this->fNcolsSub;
      trp0 += ncols;                                        // Set trp0 to the (i+1)-th row
      R__ASSERT(trp0 == cp);
   }

   R__ASSERT(cp == trp0_last && trp0 == trp0_last);
   if (isAllocated)
      delete [] trp;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSub<Element>::operator*=(const TMatrixTSym<Element> &source)
{
// Multiply submatrix with matrix source.

   if (this->fNcolsSub != source.GetNrows() || this->fNcolsSub != source.GetNcols()) {
      Error("operator*=(const TMatrixTSym<Element> &)","source matrix has wrong shape");
      return;
   }

   // Check for A *= A;
   const Element *sp;
   TMatrixTSym<Element> tmp;
   if (this->fMatrix->GetMatrixArray() == source.GetMatrixArray()) {
      tmp.ResizeTo(source);
      tmp = source;
      sp = tmp.GetMatrixArray();
   }
   else
      sp = source.GetMatrixArray();

   const Int_t ncols = this->fMatrix->GetNcols();

   // One row of the old_target matrix
   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *trp = work;
   if (this->fNcolsSub > kWorkMax) {
      isAllocated = kTRUE;
      trp = new Element[this->fNcolsSub];
   }

         Element *cp   = const_cast<Element *>(this->fMatrix->GetMatrixArray())+this->fRowOff*ncols+this->fColOff;
   const Element *trp0 = cp;                               // Pointer to  target[i,0];
   const Element * const trp0_last = trp0+this->fNrowsSub*ncols;
   while (trp0 < trp0_last) {
      memcpy(trp,trp0,this->fNcolsSub*sizeof(Element));           // copy the i-th row of target, Start at target[i,0]
      for (const Element *scp = sp; scp < sp+this->fNcolsSub; ) { // Pointer to the j-th column of source,
                                                                // Start scp = source[0,0]
         Element cij = 0;
         for (Int_t j = 0; j < this->fNcolsSub; j++) {
            cij += trp[j] * *scp;                              // the j-th col of source
            scp += this->fNcolsSub;
         }
         *cp++ = cij;
         scp -= source.GetNoElements()-1;                     // Set bcp to the (j+1)-th col
      }
      cp   += ncols-this->fNcolsSub;
      trp0 += ncols;                                         // Set trp0 to the (i+1)-th row
      R__ASSERT(trp0 == cp);
   }

   R__ASSERT(cp == trp0_last && trp0 == trp0_last);
   if (isAllocated)
      delete [] trp;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparseRow_const<Element>::TMatrixTSparseRow_const(const TMatrixTSparse<Element> &matrix,Int_t row)
{
// Constructor with row "row" of matrix

   R__ASSERT(matrix.IsValid());

   fRowInd = row-matrix.GetRowLwb();
   if (fRowInd >= matrix.GetNrows() || fRowInd < 0) {
      Error("TMatrixTSparseRow_const(const TMatrixTSparse &,Int_t)","row index out of bounds");
      fMatrix  = 0;
      fNindex  = 0;
      fColPtr  = 0;
      fDataPtr = 0;
      return;
   }

   const Int_t sIndex = matrix.GetRowIndexArray()[fRowInd];
   const Int_t eIndex = matrix.GetRowIndexArray()[fRowInd+1];
   fMatrix  = &matrix;
   fNindex  = eIndex-sIndex;
   fColPtr  = matrix.GetColIndexArray()+sIndex;
   fDataPtr = matrix.GetMatrixArray()+sIndex;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparseRow_const<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;
  }
 }

//______________________________________________________________________________
template<class Element>
TMatrixTSparseRow<Element>::TMatrixTSparseRow(TMatrixTSparse<Element> &matrix,Int_t row)
                                    : TMatrixTSparseRow_const<Element>(matrix,row)
{
// Constructor with row "row" of matrix
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparseRow<Element>::TMatrixTSparseRow(const TMatrixTSparseRow<Element> &mr)
                                    : TMatrixTSparseRow_const<Element>(mr)
{
// Copy constructor

   *this = mr;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparseRow<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;
  }
}

//______________________________________________________________________________
template<class Element>
Element &TMatrixTSparseRow<Element>::operator()(Int_t i)
{
// operator() : pick element row(i)

   R__ASSERT(this->fMatrix->IsValid());

   const Int_t acoln = i-this->fMatrix->GetColLwb();
   if (acoln >= this->fMatrix->GetNcols() || acoln < 0) {
      Error("operator()(Int_t","Requested element %d outside range : %d - %d",i,
            this->fMatrix->GetColLwb(),this->fMatrix->GetColLwb()+this->fMatrix->GetNcols());
      return (const_cast<Element*>(this->fDataPtr))[0];
   }

   Int_t index = TMath::BinarySearch(this->fNindex,this->fColPtr,acoln);
   if (index >= 0 && this->fColPtr[index] == acoln)
      return (const_cast<Element*>(this->fDataPtr))[index];
   else {
      TMatrixTSparse<Element> *mt = const_cast<TMatrixTSparse<Element> *>(this->fMatrix);
      const Int_t row = this->fRowInd+mt->GetRowLwb();
      Element val = 0.;
      mt->InsertRow(row,i,&val,1);
      const Int_t sIndex = mt->GetRowIndexArray()[this->fRowInd];
      const Int_t eIndex = mt->GetRowIndexArray()[this->fRowInd+1];
      this->fNindex  = eIndex-sIndex;
      this->fColPtr  = mt->GetColIndexArray()+sIndex;
      this->fDataPtr = mt->GetMatrixArray()+sIndex;
      index = TMath::BinarySearch(this->fNindex,this->fColPtr,acoln);
      if (index >= 0 && this->fColPtr[index] == acoln)
         return (const_cast<Element*>(this->fDataPtr))[index];
      else {
         Error("operator()(Int_t","Insert row failed");
         return (const_cast<Element*>(this->fDataPtr))[0];
      }
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator=(Element val)
{
// Assign val to every non-zero (!) element of the matrix row.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fDataPtr);
   for ( ; rp < this->fDataPtr+this->fNindex; rp++)
      *rp = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator+=(Element val)
{
// Add val to every non-zero (!) element of the matrix row.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fDataPtr);
   for ( ; rp < this->fDataPtr+this->fNindex; rp++)
      *rp += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator*=(Element val)
{
// Multiply every element of the matrix row by val.

   R__ASSERT(this->fMatrix->IsValid());
   Element *rp = const_cast<Element *>(this->fDataPtr);
   for ( ; rp < this->fDataPtr+this->fNindex; rp++)
      *rp *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator=(const TMatrixTSparseRow_const<Element> &mr)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = mr.GetMatrix();
   if (this->fMatrix == mt) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetColLwb() != mt->GetColLwb() || this->fMatrix->GetNcols() != mt->GetNcols()) {
      Error("operator=(const TMatrixTSparseRow_const &)","matrix rows not compatible");
      return;
   }

   const Int_t ncols = this->fMatrix->GetNcols();
   const Int_t row1  = this->fRowInd+this->fMatrix->GetRowLwb();
   const Int_t row2  = mr.GetRowIndex()+mt->GetRowLwb();
   const Int_t col   = this->fMatrix->GetColLwb();

   TVectorT<Element> v(ncols);
   mt->ExtractRow(row2,col,v.GetMatrixArray());
   const_cast<TMatrixTSparse<Element> *>(this->fMatrix)->InsertRow(row1,col,v.GetMatrixArray());

   const Int_t sIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd];
   const Int_t eIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd+1];
   this->fNindex  = eIndex-sIndex;
   this->fColPtr  = this->fMatrix->GetColIndexArray()+sIndex;
   this->fDataPtr = this->fMatrix->GetMatrixArray()+sIndex;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to a matrix row. The vector is considered row-vector
// to allow the assignment in the strict sense.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(vec.IsValid());

   if (this->fMatrix->GetColLwb() != vec.GetLwb() || this->fMatrix->GetNcols() != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != matrix-row length");
      return;
   }

   const Element *vp = vec.GetMatrixArray();
   const Int_t row = this->fRowInd+this->fMatrix->GetRowLwb();
   const Int_t col = this->fMatrix->GetColLwb();
   const_cast<TMatrixTSparse<Element> *>(this->fMatrix)->InsertRow(row,col,vp,vec.GetNrows());

   const Int_t sIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd];
   const Int_t eIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd+1];
   this->fNindex  = eIndex-sIndex;
   this->fColPtr  = this->fMatrix->GetColIndexArray()+sIndex;
   this->fDataPtr = this->fMatrix->GetMatrixArray()+sIndex;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator+=(const TMatrixTSparseRow_const<Element> &r)
{
// Add to every element of the matrix row the corresponding element of row r.

   const TMatrixTBase<Element> *mt = r.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetColLwb() != mt->GetColLwb() || this->fMatrix->GetNcols() != mt->GetNcols()) {
      Error("operator+=(const TMatrixTRow_const &)","different row lengths");
      return;
   }

   const Int_t ncols = this->fMatrix->GetNcols();
   const Int_t row1  = this->fRowInd+this->fMatrix->GetRowLwb();
   const Int_t row2  = r.GetRowIndex()+mt->GetRowLwb();
   const Int_t col   = this->fMatrix->GetColLwb();

   TVectorT<Element> v1(ncols);
   TVectorT<Element> v2(ncols);
   this->fMatrix->ExtractRow(row1,col,v1.GetMatrixArray());
   mt           ->ExtractRow(row2,col,v2.GetMatrixArray());
   v1 += v2;
   const_cast<TMatrixTSparse<Element> *>(this->fMatrix)->InsertRow(row1,col,v1.GetMatrixArray());

   const Int_t sIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd];
   const Int_t eIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd+1];
   this->fNindex  = eIndex-sIndex;
   this->fColPtr  = this->fMatrix->GetColIndexArray()+sIndex;
   this->fDataPtr = this->fMatrix->GetMatrixArray()+sIndex;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseRow<Element>::operator*=(const TMatrixTSparseRow_const<Element> &r)
{
// Multiply every element of the matrix row with the
// corresponding element of row r.

   const TMatrixTBase<Element> *mt = r.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fMatrix->GetColLwb() != mt->GetColLwb() || this->fMatrix->GetNcols() != mt->GetNcols()) {
      Error("operator+=(const TMatrixTRow_const &)","different row lengths");
      return;
   }

   const Int_t ncols = this->fMatrix->GetNcols();
   const Int_t row1  = r.GetRowIndex()+mt->GetRowLwb();
   const Int_t row2  = r.GetRowIndex()+mt->GetRowLwb();
   const Int_t col   = this->fMatrix->GetColLwb();

   TVectorT<Element> v1(ncols);
   TVectorT<Element> v2(ncols);
   this->fMatrix->ExtractRow(row1,col,v1.GetMatrixArray());
   mt           ->ExtractRow(row2,col,v2.GetMatrixArray());

   ElementMult(v1,v2);
   const_cast<TMatrixTSparse<Element> *>(this->fMatrix)->InsertRow(row1,col,v1.GetMatrixArray());

   const Int_t sIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd];
   const Int_t eIndex = this->fMatrix->GetRowIndexArray()[this->fRowInd+1];
   this->fNindex  = eIndex-sIndex;
   this->fColPtr  = this->fMatrix->GetColIndexArray()+sIndex;
   this->fDataPtr = this->fMatrix->GetMatrixArray()+sIndex;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparseDiag_const<Element>::TMatrixTSparseDiag_const(const TMatrixTSparse<Element> &matrix)
{
// Constructor

   R__ASSERT(matrix.IsValid());

   fMatrix  = &matrix;
   fNdiag   = TMath::Min(matrix.GetNrows(),matrix.GetNcols());
   fDataPtr = matrix.GetMatrixArray();
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparseDiag_const<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;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparseDiag<Element>::TMatrixTSparseDiag(TMatrixTSparse<Element> &matrix)
                   :TMatrixTSparseDiag_const<Element>(matrix)
{
// Constructor
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparseDiag<Element>::TMatrixTSparseDiag(const TMatrixTSparseDiag<Element> &md)
                  : TMatrixTSparseDiag_const<Element>(md)
{
// Constructor

   *this = md;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparseDiag<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;
 }

//______________________________________________________________________________
template<class Element>
Element &TMatrixTSparseDiag<Element>::operator()(Int_t i)
{
// operator() : pick element diag(i)

   R__ASSERT(this->fMatrix->IsValid());

   if (i < 0 || i >= this->fNdiag) {
      Error("operator()(Int_t","Requested element %d outside range : 0 - %d",i,this->fNdiag);
      return (const_cast<Element*>(this->fDataPtr))[0];
   }

   TMatrixTSparse<Element> *mt = const_cast<TMatrixTSparse<Element> *>(this->fMatrix);
   const Int_t *pR = mt->GetRowIndexArray();
   const Int_t *pC = mt->GetColIndexArray();
   Int_t sIndex = pR[i];
   Int_t eIndex = pR[i+1];
   Int_t index = TMath::BinarySearch(eIndex-sIndex,pC+sIndex,i)+sIndex;
   if (index >= sIndex && pC[index] == i)
      return (const_cast<Element*>(this->fDataPtr))[index];
   else {
      const Int_t row = i+mt->GetRowLwb();
      const Int_t col = i+mt->GetColLwb();
      Element val = 0.;
      mt->InsertRow(row,col,&val,1);
      this->fDataPtr = mt->GetMatrixArray();
      pR = mt->GetRowIndexArray();
      pC = mt->GetColIndexArray();
      sIndex = pR[i];
      eIndex = pR[i+1];
      index = TMath::BinarySearch(eIndex-sIndex,pC+sIndex,i)+sIndex;
      if (index >= sIndex && pC[index] == i)
         return (const_cast<Element*>(this->fDataPtr))[index];
      else {
         Error("operator()(Int_t","Insert row failed");
         return (const_cast<Element*>(this->fDataPtr))[0];
      }
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator=(Element val)
{
// Assign val to every element of the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) = val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator+=(Element val)
{
// Add val to every element of the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) += val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator*=(Element val)
{
// Multiply every element of the matrix diagonal by val.

   R__ASSERT(this->fMatrix->IsValid());
   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) *= val;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator=(const TMatrixTSparseDiag_const<Element> &md)
{
// Assignment operator

   const TMatrixTBase<Element> *mt = md.GetMatrix();
   if (this->fMatrix == mt) return;

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fNdiag != md.GetNdiags()) {
      Error("operator=(const TMatrixTSparseDiag_const &)","matrix-diagonal's different length");
      return;
   }

   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) = md(i);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator=(const TVectorT<Element> &vec)
{
// Assign a vector to the matrix diagonal.

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(vec.IsValid());

   if (this->fNdiag != vec.GetNrows()) {
      Error("operator=(const TVectorT &)","vector length != matrix-diagonal length");
      return;
   }

   const Element *vp = vec.GetMatrixArray();
   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) = vp[i];
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator+=(const TMatrixTSparseDiag_const<Element> &md)
{
// Add to every element of the matrix diagonal the
// corresponding element of diagonal md.

   const TMatrixTBase<Element> *mt = md.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fNdiag != md.GetNdiags()) {
      Error("operator+=(const TMatrixTSparseDiag_const &)","matrix-diagonal's different length");
      return;
   }

   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) += md(i);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparseDiag<Element>::operator*=(const TMatrixTSparseDiag_const<Element> &md)
{
// Multiply every element of the matrix diagonal with the
// corresponding element of diagonal md.

   const TMatrixTBase<Element> *mt = md.GetMatrix();

   R__ASSERT(this->fMatrix->IsValid());
   R__ASSERT(mt->IsValid());
   if (this->fNdiag != md.GetNdiags()) {
      Error("operator*=(const TMatrixTSparseDiag_const &)","matrix-diagonal's different length");
      return;
   }

   for (Int_t i = 0; i < this->fNdiag; i++)
      (*this)(i) *= md(i);
}

//______________________________________________________________________________
Double_t Drand(Double_t &ix)
{
// Random number generator [0....1] with seed ix

   const Double_t a   = 16807.0;
   const Double_t b15 = 32768.0;
   const Double_t b16 = 65536.0;
   const Double_t p   = 2147483647.0;
   Double_t xhi = ix/b16;
   Int_t xhiint = (Int_t) xhi;
   xhi = xhiint;
   Double_t xalo = (ix-xhi*b16)*a;

   Double_t leftlo = xalo/b16;
   Int_t leftloint = (int) leftlo;
   leftlo = leftloint;
   Double_t fhi = xhi*a+leftlo;
   Double_t k = fhi/b15;
   Int_t kint = (Int_t) k;
   k = kint;
   ix = (((xalo-leftlo*b16)-p)+(fhi-k*b15)*b16)+k;
   if (ix < 0.0) ix = ix+p;

   return (ix*4.656612875e-10);
}

template class TMatrixTRow_const       <Float_t>;
template class TMatrixTColumn_const    <Float_t>;
template class TMatrixTDiag_const      <Float_t>;
template class TMatrixTFlat_const      <Float_t>;
template class TMatrixTSub_const       <Float_t>;
template class TMatrixTSparseRow_const <Float_t>;
template class TMatrixTSparseDiag_const<Float_t>;
template class TMatrixTRow             <Float_t>;
template class TMatrixTColumn          <Float_t>;
template class TMatrixTDiag            <Float_t>;
template class TMatrixTFlat            <Float_t>;
template class TMatrixTSub             <Float_t>;
template class TMatrixTSparseRow       <Float_t>;
template class TMatrixTSparseDiag      <Float_t>;
template class TElementActionT         <Float_t>;
template class TElementPosActionT      <Float_t>;

template class TMatrixTRow_const       <Double_t>;
template class TMatrixTColumn_const    <Double_t>;
template class TMatrixTDiag_const      <Double_t>;
template class TMatrixTFlat_const      <Double_t>;
template class TMatrixTSub_const       <Double_t>;
template class TMatrixTSparseRow_const <Double_t>;
template class TMatrixTSparseDiag_const<Double_t>;
template class TMatrixTRow             <Double_t>;
template class TMatrixTColumn          <Double_t>;
template class TMatrixTDiag            <Double_t>;
template class TMatrixTFlat            <Double_t>;
template class TMatrixTSub             <Double_t>;
template class TMatrixTSparseRow       <Double_t>;
template class TMatrixTSparseDiag      <Double_t>;
template class TElementActionT         <Double_t>;
template class TElementPosActionT      <Double_t>;
 TMatrixTUtils.cxx:1
 TMatrixTUtils.cxx:2
 TMatrixTUtils.cxx:3
 TMatrixTUtils.cxx:4
 TMatrixTUtils.cxx:5
 TMatrixTUtils.cxx:6
 TMatrixTUtils.cxx:7
 TMatrixTUtils.cxx:8
 TMatrixTUtils.cxx:9
 TMatrixTUtils.cxx:10
 TMatrixTUtils.cxx:11
 TMatrixTUtils.cxx:12
 TMatrixTUtils.cxx:13
 TMatrixTUtils.cxx:14
 TMatrixTUtils.cxx:15
 TMatrixTUtils.cxx:16
 TMatrixTUtils.cxx:17
 TMatrixTUtils.cxx:18
 TMatrixTUtils.cxx:19
 TMatrixTUtils.cxx:20
 TMatrixTUtils.cxx:21
 TMatrixTUtils.cxx:22
 TMatrixTUtils.cxx:23
 TMatrixTUtils.cxx:24
 TMatrixTUtils.cxx:25
 TMatrixTUtils.cxx:26
 TMatrixTUtils.cxx:27
 TMatrixTUtils.cxx:28
 TMatrixTUtils.cxx:29
 TMatrixTUtils.cxx:30
 TMatrixTUtils.cxx:31
 TMatrixTUtils.cxx:32
 TMatrixTUtils.cxx:33
 TMatrixTUtils.cxx:34
 TMatrixTUtils.cxx:35
 TMatrixTUtils.cxx:36
 TMatrixTUtils.cxx:37
 TMatrixTUtils.cxx:38
 TMatrixTUtils.cxx:39
 TMatrixTUtils.cxx:40
 TMatrixTUtils.cxx:41
 TMatrixTUtils.cxx:42
 TMatrixTUtils.cxx:43
 TMatrixTUtils.cxx:44
 TMatrixTUtils.cxx:45
 TMatrixTUtils.cxx:46
 TMatrixTUtils.cxx:47
 TMatrixTUtils.cxx:48
 TMatrixTUtils.cxx:49
 TMatrixTUtils.cxx:50
 TMatrixTUtils.cxx:51
 TMatrixTUtils.cxx:52
 TMatrixTUtils.cxx:53
 TMatrixTUtils.cxx:54
 TMatrixTUtils.cxx:55
 TMatrixTUtils.cxx:56
 TMatrixTUtils.cxx:57
 TMatrixTUtils.cxx:58
 TMatrixTUtils.cxx:59
 TMatrixTUtils.cxx:60
 TMatrixTUtils.cxx:61
 TMatrixTUtils.cxx:62
 TMatrixTUtils.cxx:63
 TMatrixTUtils.cxx:64
 TMatrixTUtils.cxx:65
 TMatrixTUtils.cxx:66
 TMatrixTUtils.cxx:67
 TMatrixTUtils.cxx:68
 TMatrixTUtils.cxx:69
 TMatrixTUtils.cxx:70
 TMatrixTUtils.cxx:71
 TMatrixTUtils.cxx:72
 TMatrixTUtils.cxx:73
 TMatrixTUtils.cxx:74
 TMatrixTUtils.cxx:75
 TMatrixTUtils.cxx:76
 TMatrixTUtils.cxx:77
 TMatrixTUtils.cxx:78
 TMatrixTUtils.cxx:79
 TMatrixTUtils.cxx:80
 TMatrixTUtils.cxx:81
 TMatrixTUtils.cxx:82
 TMatrixTUtils.cxx:83
 TMatrixTUtils.cxx:84
 TMatrixTUtils.cxx:85
 TMatrixTUtils.cxx:86
 TMatrixTUtils.cxx:87
 TMatrixTUtils.cxx:88
 TMatrixTUtils.cxx:89
 TMatrixTUtils.cxx:90
 TMatrixTUtils.cxx:91
 TMatrixTUtils.cxx:92
 TMatrixTUtils.cxx:93
 TMatrixTUtils.cxx:94
 TMatrixTUtils.cxx:95
 TMatrixTUtils.cxx:96
 TMatrixTUtils.cxx:97
 TMatrixTUtils.cxx:98
 TMatrixTUtils.cxx:99
 TMatrixTUtils.cxx:100
 TMatrixTUtils.cxx:101
 TMatrixTUtils.cxx:102
 TMatrixTUtils.cxx:103
 TMatrixTUtils.cxx:104
 TMatrixTUtils.cxx:105
 TMatrixTUtils.cxx:106
 TMatrixTUtils.cxx:107
 TMatrixTUtils.cxx:108
 TMatrixTUtils.cxx:109
 TMatrixTUtils.cxx:110
 TMatrixTUtils.cxx:111
 TMatrixTUtils.cxx:112
 TMatrixTUtils.cxx:113
 TMatrixTUtils.cxx:114
 TMatrixTUtils.cxx:115
 TMatrixTUtils.cxx:116
 TMatrixTUtils.cxx:117
 TMatrixTUtils.cxx:118
 TMatrixTUtils.cxx:119
 TMatrixTUtils.cxx:120
 TMatrixTUtils.cxx:121
 TMatrixTUtils.cxx:122
 TMatrixTUtils.cxx:123
 TMatrixTUtils.cxx:124
 TMatrixTUtils.cxx:125
 TMatrixTUtils.cxx:126
 TMatrixTUtils.cxx:127
 TMatrixTUtils.cxx:128
 TMatrixTUtils.cxx:129
 TMatrixTUtils.cxx:130
 TMatrixTUtils.cxx:131
 TMatrixTUtils.cxx:132
 TMatrixTUtils.cxx:133
 TMatrixTUtils.cxx:134
 TMatrixTUtils.cxx:135
 TMatrixTUtils.cxx:136
 TMatrixTUtils.cxx:137
 TMatrixTUtils.cxx:138
 TMatrixTUtils.cxx:139
 TMatrixTUtils.cxx:140
 TMatrixTUtils.cxx:141
 TMatrixTUtils.cxx:142
 TMatrixTUtils.cxx:143
 TMatrixTUtils.cxx:144
 TMatrixTUtils.cxx:145
 TMatrixTUtils.cxx:146
 TMatrixTUtils.cxx:147
 TMatrixTUtils.cxx:148
 TMatrixTUtils.cxx:149
 TMatrixTUtils.cxx:150
 TMatrixTUtils.cxx:151
 TMatrixTUtils.cxx:152
 TMatrixTUtils.cxx:153
 TMatrixTUtils.cxx:154
 TMatrixTUtils.cxx:155
 TMatrixTUtils.cxx:156
 TMatrixTUtils.cxx:157
 TMatrixTUtils.cxx:158
 TMatrixTUtils.cxx:159
 TMatrixTUtils.cxx:160
 TMatrixTUtils.cxx:161
 TMatrixTUtils.cxx:162
 TMatrixTUtils.cxx:163
 TMatrixTUtils.cxx:164
 TMatrixTUtils.cxx:165
 TMatrixTUtils.cxx:166
 TMatrixTUtils.cxx:167
 TMatrixTUtils.cxx:168
 TMatrixTUtils.cxx:169
 TMatrixTUtils.cxx:170
 TMatrixTUtils.cxx:171
 TMatrixTUtils.cxx:172
 TMatrixTUtils.cxx:173
 TMatrixTUtils.cxx:174
 TMatrixTUtils.cxx:175
 TMatrixTUtils.cxx:176
 TMatrixTUtils.cxx:177
 TMatrixTUtils.cxx:178
 TMatrixTUtils.cxx:179
 TMatrixTUtils.cxx:180
 TMatrixTUtils.cxx:181
 TMatrixTUtils.cxx:182
 TMatrixTUtils.cxx:183
 TMatrixTUtils.cxx:184
 TMatrixTUtils.cxx:185
 TMatrixTUtils.cxx:186
 TMatrixTUtils.cxx:187
 TMatrixTUtils.cxx:188
 TMatrixTUtils.cxx:189
 TMatrixTUtils.cxx:190
 TMatrixTUtils.cxx:191
 TMatrixTUtils.cxx:192
 TMatrixTUtils.cxx:193
 TMatrixTUtils.cxx:194
 TMatrixTUtils.cxx:195
 TMatrixTUtils.cxx:196
 TMatrixTUtils.cxx:197
 TMatrixTUtils.cxx:198
 TMatrixTUtils.cxx:199
 TMatrixTUtils.cxx:200
 TMatrixTUtils.cxx:201
 TMatrixTUtils.cxx:202
 TMatrixTUtils.cxx:203
 TMatrixTUtils.cxx:204
 TMatrixTUtils.cxx:205
 TMatrixTUtils.cxx:206
 TMatrixTUtils.cxx:207
 TMatrixTUtils.cxx:208
 TMatrixTUtils.cxx:209
 TMatrixTUtils.cxx:210
 TMatrixTUtils.cxx:211
 TMatrixTUtils.cxx:212
 TMatrixTUtils.cxx:213
 TMatrixTUtils.cxx:214
 TMatrixTUtils.cxx:215
 TMatrixTUtils.cxx:216
 TMatrixTUtils.cxx:217
 TMatrixTUtils.cxx:218
 TMatrixTUtils.cxx:219
 TMatrixTUtils.cxx:220
 TMatrixTUtils.cxx:221
 TMatrixTUtils.cxx:222
 TMatrixTUtils.cxx:223
 TMatrixTUtils.cxx:224
 TMatrixTUtils.cxx:225
 TMatrixTUtils.cxx:226
 TMatrixTUtils.cxx:227
 TMatrixTUtils.cxx:228
 TMatrixTUtils.cxx:229
 TMatrixTUtils.cxx:230
 TMatrixTUtils.cxx:231
 TMatrixTUtils.cxx:232
 TMatrixTUtils.cxx:233
 TMatrixTUtils.cxx:234
 TMatrixTUtils.cxx:235
 TMatrixTUtils.cxx:236
 TMatrixTUtils.cxx:237
 TMatrixTUtils.cxx:238
 TMatrixTUtils.cxx:239
 TMatrixTUtils.cxx:240
 TMatrixTUtils.cxx:241
 TMatrixTUtils.cxx:242
 TMatrixTUtils.cxx:243
 TMatrixTUtils.cxx:244
 TMatrixTUtils.cxx:245
 TMatrixTUtils.cxx:246
 TMatrixTUtils.cxx:247
 TMatrixTUtils.cxx:248
 TMatrixTUtils.cxx:249
 TMatrixTUtils.cxx:250
 TMatrixTUtils.cxx:251
 TMatrixTUtils.cxx:252
 TMatrixTUtils.cxx:253
 TMatrixTUtils.cxx:254
 TMatrixTUtils.cxx:255
 TMatrixTUtils.cxx:256
 TMatrixTUtils.cxx:257
 TMatrixTUtils.cxx:258
 TMatrixTUtils.cxx:259
 TMatrixTUtils.cxx:260
 TMatrixTUtils.cxx:261
 TMatrixTUtils.cxx:262
 TMatrixTUtils.cxx:263
 TMatrixTUtils.cxx:264
 TMatrixTUtils.cxx:265
 TMatrixTUtils.cxx:266
 TMatrixTUtils.cxx:267
 TMatrixTUtils.cxx:268
 TMatrixTUtils.cxx:269
 TMatrixTUtils.cxx:270
 TMatrixTUtils.cxx:271
 TMatrixTUtils.cxx:272
 TMatrixTUtils.cxx:273
 TMatrixTUtils.cxx:274
 TMatrixTUtils.cxx:275
 TMatrixTUtils.cxx:276
 TMatrixTUtils.cxx:277
 TMatrixTUtils.cxx:278
 TMatrixTUtils.cxx:279
 TMatrixTUtils.cxx:280
 TMatrixTUtils.cxx:281
 TMatrixTUtils.cxx:282
 TMatrixTUtils.cxx:283
 TMatrixTUtils.cxx:284
 TMatrixTUtils.cxx:285
 TMatrixTUtils.cxx:286
 TMatrixTUtils.cxx:287
 TMatrixTUtils.cxx:288
 TMatrixTUtils.cxx:289
 TMatrixTUtils.cxx:290
 TMatrixTUtils.cxx:291
 TMatrixTUtils.cxx:292
 TMatrixTUtils.cxx:293
 TMatrixTUtils.cxx:294
 TMatrixTUtils.cxx:295
 TMatrixTUtils.cxx:296
 TMatrixTUtils.cxx:297
 TMatrixTUtils.cxx:298
 TMatrixTUtils.cxx:299
 TMatrixTUtils.cxx:300
 TMatrixTUtils.cxx:301
 TMatrixTUtils.cxx:302
 TMatrixTUtils.cxx:303
 TMatrixTUtils.cxx:304
 TMatrixTUtils.cxx:305
 TMatrixTUtils.cxx:306
 TMatrixTUtils.cxx:307
 TMatrixTUtils.cxx:308
 TMatrixTUtils.cxx:309
 TMatrixTUtils.cxx:310
 TMatrixTUtils.cxx:311
 TMatrixTUtils.cxx:312
 TMatrixTUtils.cxx:313
 TMatrixTUtils.cxx:314
 TMatrixTUtils.cxx:315
 TMatrixTUtils.cxx:316
 TMatrixTUtils.cxx:317
 TMatrixTUtils.cxx:318
 TMatrixTUtils.cxx:319
 TMatrixTUtils.cxx:320
 TMatrixTUtils.cxx:321
 TMatrixTUtils.cxx:322
 TMatrixTUtils.cxx:323
 TMatrixTUtils.cxx:324
 TMatrixTUtils.cxx:325
 TMatrixTUtils.cxx:326
 TMatrixTUtils.cxx:327
 TMatrixTUtils.cxx:328
 TMatrixTUtils.cxx:329
 TMatrixTUtils.cxx:330
 TMatrixTUtils.cxx:331
 TMatrixTUtils.cxx:332
 TMatrixTUtils.cxx:333
 TMatrixTUtils.cxx:334
 TMatrixTUtils.cxx:335
 TMatrixTUtils.cxx:336
 TMatrixTUtils.cxx:337
 TMatrixTUtils.cxx:338
 TMatrixTUtils.cxx:339
 TMatrixTUtils.cxx:340
 TMatrixTUtils.cxx:341
 TMatrixTUtils.cxx:342
 TMatrixTUtils.cxx:343
 TMatrixTUtils.cxx:344
 TMatrixTUtils.cxx:345
 TMatrixTUtils.cxx:346
 TMatrixTUtils.cxx:347
 TMatrixTUtils.cxx:348
 TMatrixTUtils.cxx:349
 TMatrixTUtils.cxx:350
 TMatrixTUtils.cxx:351
 TMatrixTUtils.cxx:352
 TMatrixTUtils.cxx:353
 TMatrixTUtils.cxx:354
 TMatrixTUtils.cxx:355
 TMatrixTUtils.cxx:356
 TMatrixTUtils.cxx:357
 TMatrixTUtils.cxx:358
 TMatrixTUtils.cxx:359
 TMatrixTUtils.cxx:360
 TMatrixTUtils.cxx:361
 TMatrixTUtils.cxx:362
 TMatrixTUtils.cxx:363
 TMatrixTUtils.cxx:364
 TMatrixTUtils.cxx:365
 TMatrixTUtils.cxx:366
 TMatrixTUtils.cxx:367
 TMatrixTUtils.cxx:368
 TMatrixTUtils.cxx:369
 TMatrixTUtils.cxx:370
 TMatrixTUtils.cxx:371
 TMatrixTUtils.cxx:372
 TMatrixTUtils.cxx:373
 TMatrixTUtils.cxx:374
 TMatrixTUtils.cxx:375
 TMatrixTUtils.cxx:376
 TMatrixTUtils.cxx:377
 TMatrixTUtils.cxx:378
 TMatrixTUtils.cxx:379
 TMatrixTUtils.cxx:380
 TMatrixTUtils.cxx:381
 TMatrixTUtils.cxx:382
 TMatrixTUtils.cxx:383
 TMatrixTUtils.cxx:384
 TMatrixTUtils.cxx:385
 TMatrixTUtils.cxx:386
 TMatrixTUtils.cxx:387
 TMatrixTUtils.cxx:388
 TMatrixTUtils.cxx:389
 TMatrixTUtils.cxx:390
 TMatrixTUtils.cxx:391
 TMatrixTUtils.cxx:392
 TMatrixTUtils.cxx:393
 TMatrixTUtils.cxx:394
 TMatrixTUtils.cxx:395
 TMatrixTUtils.cxx:396
 TMatrixTUtils.cxx:397
 TMatrixTUtils.cxx:398
 TMatrixTUtils.cxx:399
 TMatrixTUtils.cxx:400
 TMatrixTUtils.cxx:401
 TMatrixTUtils.cxx:402
 TMatrixTUtils.cxx:403
 TMatrixTUtils.cxx:404
 TMatrixTUtils.cxx:405
 TMatrixTUtils.cxx:406
 TMatrixTUtils.cxx:407
 TMatrixTUtils.cxx:408
 TMatrixTUtils.cxx:409
 TMatrixTUtils.cxx:410
 TMatrixTUtils.cxx:411
 TMatrixTUtils.cxx:412
 TMatrixTUtils.cxx:413
 TMatrixTUtils.cxx:414
 TMatrixTUtils.cxx:415
 TMatrixTUtils.cxx:416
 TMatrixTUtils.cxx:417
 TMatrixTUtils.cxx:418
 TMatrixTUtils.cxx:419
 TMatrixTUtils.cxx:420
 TMatrixTUtils.cxx:421
 TMatrixTUtils.cxx:422
 TMatrixTUtils.cxx:423
 TMatrixTUtils.cxx:424
 TMatrixTUtils.cxx:425
 TMatrixTUtils.cxx:426
 TMatrixTUtils.cxx:427
 TMatrixTUtils.cxx:428
 TMatrixTUtils.cxx:429
 TMatrixTUtils.cxx:430
 TMatrixTUtils.cxx:431
 TMatrixTUtils.cxx:432
 TMatrixTUtils.cxx:433
 TMatrixTUtils.cxx:434
 TMatrixTUtils.cxx:435
 TMatrixTUtils.cxx:436
 TMatrixTUtils.cxx:437
 TMatrixTUtils.cxx:438
 TMatrixTUtils.cxx:439
 TMatrixTUtils.cxx:440
 TMatrixTUtils.cxx:441
 TMatrixTUtils.cxx:442
 TMatrixTUtils.cxx:443
 TMatrixTUtils.cxx:444
 TMatrixTUtils.cxx:445
 TMatrixTUtils.cxx:446
 TMatrixTUtils.cxx:447
 TMatrixTUtils.cxx:448
 TMatrixTUtils.cxx:449
 TMatrixTUtils.cxx:450
 TMatrixTUtils.cxx:451
 TMatrixTUtils.cxx:452
 TMatrixTUtils.cxx:453
 TMatrixTUtils.cxx:454
 TMatrixTUtils.cxx:455
 TMatrixTUtils.cxx:456
 TMatrixTUtils.cxx:457
 TMatrixTUtils.cxx:458
 TMatrixTUtils.cxx:459
 TMatrixTUtils.cxx:460
 TMatrixTUtils.cxx:461
 TMatrixTUtils.cxx:462
 TMatrixTUtils.cxx:463
 TMatrixTUtils.cxx:464
 TMatrixTUtils.cxx:465
 TMatrixTUtils.cxx:466
 TMatrixTUtils.cxx:467
 TMatrixTUtils.cxx:468
 TMatrixTUtils.cxx:469
 TMatrixTUtils.cxx:470
 TMatrixTUtils.cxx:471
 TMatrixTUtils.cxx:472
 TMatrixTUtils.cxx:473
 TMatrixTUtils.cxx:474
 TMatrixTUtils.cxx:475
 TMatrixTUtils.cxx:476
 TMatrixTUtils.cxx:477
 TMatrixTUtils.cxx:478
 TMatrixTUtils.cxx:479
 TMatrixTUtils.cxx:480
 TMatrixTUtils.cxx:481
 TMatrixTUtils.cxx:482
 TMatrixTUtils.cxx:483
 TMatrixTUtils.cxx:484
 TMatrixTUtils.cxx:485
 TMatrixTUtils.cxx:486
 TMatrixTUtils.cxx:487
 TMatrixTUtils.cxx:488
 TMatrixTUtils.cxx:489
 TMatrixTUtils.cxx:490
 TMatrixTUtils.cxx:491
 TMatrixTUtils.cxx:492
 TMatrixTUtils.cxx:493
 TMatrixTUtils.cxx:494
 TMatrixTUtils.cxx:495
 TMatrixTUtils.cxx:496
 TMatrixTUtils.cxx:497
 TMatrixTUtils.cxx:498
 TMatrixTUtils.cxx:499
 TMatrixTUtils.cxx:500
 TMatrixTUtils.cxx:501
 TMatrixTUtils.cxx:502
 TMatrixTUtils.cxx:503
 TMatrixTUtils.cxx:504
 TMatrixTUtils.cxx:505
 TMatrixTUtils.cxx:506
 TMatrixTUtils.cxx:507
 TMatrixTUtils.cxx:508
 TMatrixTUtils.cxx:509
 TMatrixTUtils.cxx:510
 TMatrixTUtils.cxx:511
 TMatrixTUtils.cxx:512
 TMatrixTUtils.cxx:513
 TMatrixTUtils.cxx:514
 TMatrixTUtils.cxx:515
 TMatrixTUtils.cxx:516
 TMatrixTUtils.cxx:517
 TMatrixTUtils.cxx:518
 TMatrixTUtils.cxx:519
 TMatrixTUtils.cxx:520
 TMatrixTUtils.cxx:521
 TMatrixTUtils.cxx:522
 TMatrixTUtils.cxx:523
 TMatrixTUtils.cxx:524
 TMatrixTUtils.cxx:525
 TMatrixTUtils.cxx:526
 TMatrixTUtils.cxx:527
 TMatrixTUtils.cxx:528
 TMatrixTUtils.cxx:529
 TMatrixTUtils.cxx:530
 TMatrixTUtils.cxx:531
 TMatrixTUtils.cxx:532
 TMatrixTUtils.cxx:533
 TMatrixTUtils.cxx:534
 TMatrixTUtils.cxx:535
 TMatrixTUtils.cxx:536
 TMatrixTUtils.cxx:537
 TMatrixTUtils.cxx:538
 TMatrixTUtils.cxx:539
 TMatrixTUtils.cxx:540
 TMatrixTUtils.cxx:541
 TMatrixTUtils.cxx:542
 TMatrixTUtils.cxx:543
 TMatrixTUtils.cxx:544
 TMatrixTUtils.cxx:545
 TMatrixTUtils.cxx:546
 TMatrixTUtils.cxx:547
 TMatrixTUtils.cxx:548
 TMatrixTUtils.cxx:549
 TMatrixTUtils.cxx:550
 TMatrixTUtils.cxx:551
 TMatrixTUtils.cxx:552
 TMatrixTUtils.cxx:553
 TMatrixTUtils.cxx:554
 TMatrixTUtils.cxx:555
 TMatrixTUtils.cxx:556
 TMatrixTUtils.cxx:557
 TMatrixTUtils.cxx:558
 TMatrixTUtils.cxx:559
 TMatrixTUtils.cxx:560
 TMatrixTUtils.cxx:561
 TMatrixTUtils.cxx:562
 TMatrixTUtils.cxx:563
 TMatrixTUtils.cxx:564
 TMatrixTUtils.cxx:565
 TMatrixTUtils.cxx:566
 TMatrixTUtils.cxx:567
 TMatrixTUtils.cxx:568
 TMatrixTUtils.cxx:569
 TMatrixTUtils.cxx:570
 TMatrixTUtils.cxx:571
 TMatrixTUtils.cxx:572
 TMatrixTUtils.cxx:573
 TMatrixTUtils.cxx:574
 TMatrixTUtils.cxx:575
 TMatrixTUtils.cxx:576
 TMatrixTUtils.cxx:577
 TMatrixTUtils.cxx:578
 TMatrixTUtils.cxx:579
 TMatrixTUtils.cxx:580
 TMatrixTUtils.cxx:581
 TMatrixTUtils.cxx:582
 TMatrixTUtils.cxx:583
 TMatrixTUtils.cxx:584
 TMatrixTUtils.cxx:585
 TMatrixTUtils.cxx:586
 TMatrixTUtils.cxx:587
 TMatrixTUtils.cxx:588
 TMatrixTUtils.cxx:589
 TMatrixTUtils.cxx:590
 TMatrixTUtils.cxx:591
 TMatrixTUtils.cxx:592
 TMatrixTUtils.cxx:593
 TMatrixTUtils.cxx:594
 TMatrixTUtils.cxx:595
 TMatrixTUtils.cxx:596
 TMatrixTUtils.cxx:597
 TMatrixTUtils.cxx:598
 TMatrixTUtils.cxx:599
 TMatrixTUtils.cxx:600
 TMatrixTUtils.cxx:601
 TMatrixTUtils.cxx:602
 TMatrixTUtils.cxx:603
 TMatrixTUtils.cxx:604
 TMatrixTUtils.cxx:605
 TMatrixTUtils.cxx:606
 TMatrixTUtils.cxx:607
 TMatrixTUtils.cxx:608
 TMatrixTUtils.cxx:609
 TMatrixTUtils.cxx:610
 TMatrixTUtils.cxx:611
 TMatrixTUtils.cxx:612
 TMatrixTUtils.cxx:613
 TMatrixTUtils.cxx:614
 TMatrixTUtils.cxx:615
 TMatrixTUtils.cxx:616
 TMatrixTUtils.cxx:617
 TMatrixTUtils.cxx:618
 TMatrixTUtils.cxx:619
 TMatrixTUtils.cxx:620
 TMatrixTUtils.cxx:621
 TMatrixTUtils.cxx:622
 TMatrixTUtils.cxx:623
 TMatrixTUtils.cxx:624
 TMatrixTUtils.cxx:625
 TMatrixTUtils.cxx:626
 TMatrixTUtils.cxx:627
 TMatrixTUtils.cxx:628
 TMatrixTUtils.cxx:629
 TMatrixTUtils.cxx:630
 TMatrixTUtils.cxx:631
 TMatrixTUtils.cxx:632
 TMatrixTUtils.cxx:633
 TMatrixTUtils.cxx:634
 TMatrixTUtils.cxx:635
 TMatrixTUtils.cxx:636
 TMatrixTUtils.cxx:637
 TMatrixTUtils.cxx:638
 TMatrixTUtils.cxx:639
 TMatrixTUtils.cxx:640
 TMatrixTUtils.cxx:641
 TMatrixTUtils.cxx:642
 TMatrixTUtils.cxx:643
 TMatrixTUtils.cxx:644
 TMatrixTUtils.cxx:645
 TMatrixTUtils.cxx:646
 TMatrixTUtils.cxx:647
 TMatrixTUtils.cxx:648
 TMatrixTUtils.cxx:649
 TMatrixTUtils.cxx:650
 TMatrixTUtils.cxx:651
 TMatrixTUtils.cxx:652
 TMatrixTUtils.cxx:653
 TMatrixTUtils.cxx:654
 TMatrixTUtils.cxx:655
 TMatrixTUtils.cxx:656
 TMatrixTUtils.cxx:657
 TMatrixTUtils.cxx:658
 TMatrixTUtils.cxx:659
 TMatrixTUtils.cxx:660
 TMatrixTUtils.cxx:661
 TMatrixTUtils.cxx:662
 TMatrixTUtils.cxx:663
 TMatrixTUtils.cxx:664
 TMatrixTUtils.cxx:665
 TMatrixTUtils.cxx:666
 TMatrixTUtils.cxx:667
 TMatrixTUtils.cxx:668
 TMatrixTUtils.cxx:669
 TMatrixTUtils.cxx:670
 TMatrixTUtils.cxx:671
 TMatrixTUtils.cxx:672
 TMatrixTUtils.cxx:673
 TMatrixTUtils.cxx:674
 TMatrixTUtils.cxx:675
 TMatrixTUtils.cxx:676
 TMatrixTUtils.cxx:677
 TMatrixTUtils.cxx:678
 TMatrixTUtils.cxx:679
 TMatrixTUtils.cxx:680
 TMatrixTUtils.cxx:681
 TMatrixTUtils.cxx:682
 TMatrixTUtils.cxx:683
 TMatrixTUtils.cxx:684
 TMatrixTUtils.cxx:685
 TMatrixTUtils.cxx:686
 TMatrixTUtils.cxx:687
 TMatrixTUtils.cxx:688
 TMatrixTUtils.cxx:689
 TMatrixTUtils.cxx:690
 TMatrixTUtils.cxx:691
 TMatrixTUtils.cxx:692
 TMatrixTUtils.cxx:693
 TMatrixTUtils.cxx:694
 TMatrixTUtils.cxx:695
 TMatrixTUtils.cxx:696
 TMatrixTUtils.cxx:697
 TMatrixTUtils.cxx:698
 TMatrixTUtils.cxx:699
 TMatrixTUtils.cxx:700
 TMatrixTUtils.cxx:701
 TMatrixTUtils.cxx:702
 TMatrixTUtils.cxx:703
 TMatrixTUtils.cxx:704
 TMatrixTUtils.cxx:705
 TMatrixTUtils.cxx:706
 TMatrixTUtils.cxx:707
 TMatrixTUtils.cxx:708
 TMatrixTUtils.cxx:709
 TMatrixTUtils.cxx:710
 TMatrixTUtils.cxx:711
 TMatrixTUtils.cxx:712
 TMatrixTUtils.cxx:713
 TMatrixTUtils.cxx:714
 TMatrixTUtils.cxx:715
 TMatrixTUtils.cxx:716
 TMatrixTUtils.cxx:717
 TMatrixTUtils.cxx:718
 TMatrixTUtils.cxx:719
 TMatrixTUtils.cxx:720
 TMatrixTUtils.cxx:721
 TMatrixTUtils.cxx:722
 TMatrixTUtils.cxx:723
 TMatrixTUtils.cxx:724
 TMatrixTUtils.cxx:725
 TMatrixTUtils.cxx:726
 TMatrixTUtils.cxx:727
 TMatrixTUtils.cxx:728
 TMatrixTUtils.cxx:729
 TMatrixTUtils.cxx:730
 TMatrixTUtils.cxx:731
 TMatrixTUtils.cxx:732
 TMatrixTUtils.cxx:733
 TMatrixTUtils.cxx:734
 TMatrixTUtils.cxx:735
 TMatrixTUtils.cxx:736
 TMatrixTUtils.cxx:737
 TMatrixTUtils.cxx:738
 TMatrixTUtils.cxx:739
 TMatrixTUtils.cxx:740
 TMatrixTUtils.cxx:741
 TMatrixTUtils.cxx:742
 TMatrixTUtils.cxx:743
 TMatrixTUtils.cxx:744
 TMatrixTUtils.cxx:745
 TMatrixTUtils.cxx:746
 TMatrixTUtils.cxx:747
 TMatrixTUtils.cxx:748
 TMatrixTUtils.cxx:749
 TMatrixTUtils.cxx:750
 TMatrixTUtils.cxx:751
 TMatrixTUtils.cxx:752
 TMatrixTUtils.cxx:753
 TMatrixTUtils.cxx:754
 TMatrixTUtils.cxx:755
 TMatrixTUtils.cxx:756
 TMatrixTUtils.cxx:757
 TMatrixTUtils.cxx:758
 TMatrixTUtils.cxx:759
 TMatrixTUtils.cxx:760
 TMatrixTUtils.cxx:761
 TMatrixTUtils.cxx:762
 TMatrixTUtils.cxx:763
 TMatrixTUtils.cxx:764
 TMatrixTUtils.cxx:765
 TMatrixTUtils.cxx:766
 TMatrixTUtils.cxx:767
 TMatrixTUtils.cxx:768
 TMatrixTUtils.cxx:769
 TMatrixTUtils.cxx:770
 TMatrixTUtils.cxx:771
 TMatrixTUtils.cxx:772
 TMatrixTUtils.cxx:773
 TMatrixTUtils.cxx:774
 TMatrixTUtils.cxx:775
 TMatrixTUtils.cxx:776
 TMatrixTUtils.cxx:777
 TMatrixTUtils.cxx:778
 TMatrixTUtils.cxx:779
 TMatrixTUtils.cxx:780
 TMatrixTUtils.cxx:781
 TMatrixTUtils.cxx:782
 TMatrixTUtils.cxx:783
 TMatrixTUtils.cxx:784
 TMatrixTUtils.cxx:785
 TMatrixTUtils.cxx:786
 TMatrixTUtils.cxx:787
 TMatrixTUtils.cxx:788
 TMatrixTUtils.cxx:789
 TMatrixTUtils.cxx:790
 TMatrixTUtils.cxx:791
 TMatrixTUtils.cxx:792
 TMatrixTUtils.cxx:793
 TMatrixTUtils.cxx:794
 TMatrixTUtils.cxx:795
 TMatrixTUtils.cxx:796
 TMatrixTUtils.cxx:797
 TMatrixTUtils.cxx:798
 TMatrixTUtils.cxx:799
 TMatrixTUtils.cxx:800
 TMatrixTUtils.cxx:801
 TMatrixTUtils.cxx:802
 TMatrixTUtils.cxx:803
 TMatrixTUtils.cxx:804
 TMatrixTUtils.cxx:805
 TMatrixTUtils.cxx:806
 TMatrixTUtils.cxx:807
 TMatrixTUtils.cxx:808
 TMatrixTUtils.cxx:809
 TMatrixTUtils.cxx:810
 TMatrixTUtils.cxx:811
 TMatrixTUtils.cxx:812
 TMatrixTUtils.cxx:813
 TMatrixTUtils.cxx:814
 TMatrixTUtils.cxx:815
 TMatrixTUtils.cxx:816
 TMatrixTUtils.cxx:817
 TMatrixTUtils.cxx:818
 TMatrixTUtils.cxx:819
 TMatrixTUtils.cxx:820
 TMatrixTUtils.cxx:821
 TMatrixTUtils.cxx:822
 TMatrixTUtils.cxx:823
 TMatrixTUtils.cxx:824
 TMatrixTUtils.cxx:825
 TMatrixTUtils.cxx:826
 TMatrixTUtils.cxx:827
 TMatrixTUtils.cxx:828
 TMatrixTUtils.cxx:829
 TMatrixTUtils.cxx:830
 TMatrixTUtils.cxx:831
 TMatrixTUtils.cxx:832
 TMatrixTUtils.cxx:833
 TMatrixTUtils.cxx:834
 TMatrixTUtils.cxx:835
 TMatrixTUtils.cxx:836
 TMatrixTUtils.cxx:837
 TMatrixTUtils.cxx:838
 TMatrixTUtils.cxx:839
 TMatrixTUtils.cxx:840
 TMatrixTUtils.cxx:841
 TMatrixTUtils.cxx:842
 TMatrixTUtils.cxx:843
 TMatrixTUtils.cxx:844
 TMatrixTUtils.cxx:845
 TMatrixTUtils.cxx:846
 TMatrixTUtils.cxx:847
 TMatrixTUtils.cxx:848
 TMatrixTUtils.cxx:849
 TMatrixTUtils.cxx:850
 TMatrixTUtils.cxx:851
 TMatrixTUtils.cxx:852
 TMatrixTUtils.cxx:853
 TMatrixTUtils.cxx:854
 TMatrixTUtils.cxx:855
 TMatrixTUtils.cxx:856
 TMatrixTUtils.cxx:857
 TMatrixTUtils.cxx:858
 TMatrixTUtils.cxx:859
 TMatrixTUtils.cxx:860
 TMatrixTUtils.cxx:861
 TMatrixTUtils.cxx:862
 TMatrixTUtils.cxx:863
 TMatrixTUtils.cxx:864
 TMatrixTUtils.cxx:865
 TMatrixTUtils.cxx:866
 TMatrixTUtils.cxx:867
 TMatrixTUtils.cxx:868
 TMatrixTUtils.cxx:869
 TMatrixTUtils.cxx:870
 TMatrixTUtils.cxx:871
 TMatrixTUtils.cxx:872
 TMatrixTUtils.cxx:873
 TMatrixTUtils.cxx:874
 TMatrixTUtils.cxx:875
 TMatrixTUtils.cxx:876
 TMatrixTUtils.cxx:877
 TMatrixTUtils.cxx:878
 TMatrixTUtils.cxx:879
 TMatrixTUtils.cxx:880
 TMatrixTUtils.cxx:881
 TMatrixTUtils.cxx:882
 TMatrixTUtils.cxx:883
 TMatrixTUtils.cxx:884
 TMatrixTUtils.cxx:885
 TMatrixTUtils.cxx:886
 TMatrixTUtils.cxx:887
 TMatrixTUtils.cxx:888
 TMatrixTUtils.cxx:889
 TMatrixTUtils.cxx:890
 TMatrixTUtils.cxx:891
 TMatrixTUtils.cxx:892
 TMatrixTUtils.cxx:893
 TMatrixTUtils.cxx:894
 TMatrixTUtils.cxx:895
 TMatrixTUtils.cxx:896
 TMatrixTUtils.cxx:897
 TMatrixTUtils.cxx:898
 TMatrixTUtils.cxx:899
 TMatrixTUtils.cxx:900
 TMatrixTUtils.cxx:901
 TMatrixTUtils.cxx:902
 TMatrixTUtils.cxx:903
 TMatrixTUtils.cxx:904
 TMatrixTUtils.cxx:905
 TMatrixTUtils.cxx:906
 TMatrixTUtils.cxx:907
 TMatrixTUtils.cxx:908
 TMatrixTUtils.cxx:909
 TMatrixTUtils.cxx:910
 TMatrixTUtils.cxx:911
 TMatrixTUtils.cxx:912
 TMatrixTUtils.cxx:913
 TMatrixTUtils.cxx:914
 TMatrixTUtils.cxx:915
 TMatrixTUtils.cxx:916
 TMatrixTUtils.cxx:917
 TMatrixTUtils.cxx:918
 TMatrixTUtils.cxx:919
 TMatrixTUtils.cxx:920
 TMatrixTUtils.cxx:921
 TMatrixTUtils.cxx:922
 TMatrixTUtils.cxx:923
 TMatrixTUtils.cxx:924
 TMatrixTUtils.cxx:925
 TMatrixTUtils.cxx:926
 TMatrixTUtils.cxx:927
 TMatrixTUtils.cxx:928
 TMatrixTUtils.cxx:929
 TMatrixTUtils.cxx:930
 TMatrixTUtils.cxx:931
 TMatrixTUtils.cxx:932
 TMatrixTUtils.cxx:933
 TMatrixTUtils.cxx:934
 TMatrixTUtils.cxx:935
 TMatrixTUtils.cxx:936
 TMatrixTUtils.cxx:937
 TMatrixTUtils.cxx:938
 TMatrixTUtils.cxx:939
 TMatrixTUtils.cxx:940
 TMatrixTUtils.cxx:941
 TMatrixTUtils.cxx:942
 TMatrixTUtils.cxx:943
 TMatrixTUtils.cxx:944
 TMatrixTUtils.cxx:945
 TMatrixTUtils.cxx:946
 TMatrixTUtils.cxx:947
 TMatrixTUtils.cxx:948
 TMatrixTUtils.cxx:949
 TMatrixTUtils.cxx:950
 TMatrixTUtils.cxx:951
 TMatrixTUtils.cxx:952
 TMatrixTUtils.cxx:953
 TMatrixTUtils.cxx:954
 TMatrixTUtils.cxx:955
 TMatrixTUtils.cxx:956
 TMatrixTUtils.cxx:957
 TMatrixTUtils.cxx:958
 TMatrixTUtils.cxx:959
 TMatrixTUtils.cxx:960
 TMatrixTUtils.cxx:961
 TMatrixTUtils.cxx:962
 TMatrixTUtils.cxx:963
 TMatrixTUtils.cxx:964
 TMatrixTUtils.cxx:965
 TMatrixTUtils.cxx:966
 TMatrixTUtils.cxx:967
 TMatrixTUtils.cxx:968
 TMatrixTUtils.cxx:969
 TMatrixTUtils.cxx:970
 TMatrixTUtils.cxx:971
 TMatrixTUtils.cxx:972
 TMatrixTUtils.cxx:973
 TMatrixTUtils.cxx:974
 TMatrixTUtils.cxx:975
 TMatrixTUtils.cxx:976
 TMatrixTUtils.cxx:977
 TMatrixTUtils.cxx:978
 TMatrixTUtils.cxx:979
 TMatrixTUtils.cxx:980
 TMatrixTUtils.cxx:981
 TMatrixTUtils.cxx:982
 TMatrixTUtils.cxx:983
 TMatrixTUtils.cxx:984
 TMatrixTUtils.cxx:985
 TMatrixTUtils.cxx:986
 TMatrixTUtils.cxx:987
 TMatrixTUtils.cxx:988
 TMatrixTUtils.cxx:989
 TMatrixTUtils.cxx:990
 TMatrixTUtils.cxx:991
 TMatrixTUtils.cxx:992
 TMatrixTUtils.cxx:993
 TMatrixTUtils.cxx:994
 TMatrixTUtils.cxx:995
 TMatrixTUtils.cxx:996
 TMatrixTUtils.cxx:997
 TMatrixTUtils.cxx:998
 TMatrixTUtils.cxx:999
 TMatrixTUtils.cxx:1000
 TMatrixTUtils.cxx:1001
 TMatrixTUtils.cxx:1002
 TMatrixTUtils.cxx:1003
 TMatrixTUtils.cxx:1004
 TMatrixTUtils.cxx:1005
 TMatrixTUtils.cxx:1006
 TMatrixTUtils.cxx:1007
 TMatrixTUtils.cxx:1008
 TMatrixTUtils.cxx:1009
 TMatrixTUtils.cxx:1010
 TMatrixTUtils.cxx:1011
 TMatrixTUtils.cxx:1012
 TMatrixTUtils.cxx:1013
 TMatrixTUtils.cxx:1014
 TMatrixTUtils.cxx:1015
 TMatrixTUtils.cxx:1016
 TMatrixTUtils.cxx:1017
 TMatrixTUtils.cxx:1018
 TMatrixTUtils.cxx:1019
 TMatrixTUtils.cxx:1020
 TMatrixTUtils.cxx:1021
 TMatrixTUtils.cxx:1022
 TMatrixTUtils.cxx:1023
 TMatrixTUtils.cxx:1024
 TMatrixTUtils.cxx:1025
 TMatrixTUtils.cxx:1026
 TMatrixTUtils.cxx:1027
 TMatrixTUtils.cxx:1028
 TMatrixTUtils.cxx:1029
 TMatrixTUtils.cxx:1030
 TMatrixTUtils.cxx:1031
 TMatrixTUtils.cxx:1032
 TMatrixTUtils.cxx:1033
 TMatrixTUtils.cxx:1034
 TMatrixTUtils.cxx:1035
 TMatrixTUtils.cxx:1036
 TMatrixTUtils.cxx:1037
 TMatrixTUtils.cxx:1038
 TMatrixTUtils.cxx:1039
 TMatrixTUtils.cxx:1040
 TMatrixTUtils.cxx:1041
 TMatrixTUtils.cxx:1042
 TMatrixTUtils.cxx:1043
 TMatrixTUtils.cxx:1044
 TMatrixTUtils.cxx:1045
 TMatrixTUtils.cxx:1046
 TMatrixTUtils.cxx:1047
 TMatrixTUtils.cxx:1048
 TMatrixTUtils.cxx:1049
 TMatrixTUtils.cxx:1050
 TMatrixTUtils.cxx:1051
 TMatrixTUtils.cxx:1052
 TMatrixTUtils.cxx:1053
 TMatrixTUtils.cxx:1054
 TMatrixTUtils.cxx:1055
 TMatrixTUtils.cxx:1056
 TMatrixTUtils.cxx:1057
 TMatrixTUtils.cxx:1058
 TMatrixTUtils.cxx:1059
 TMatrixTUtils.cxx:1060
 TMatrixTUtils.cxx:1061
 TMatrixTUtils.cxx:1062
 TMatrixTUtils.cxx:1063
 TMatrixTUtils.cxx:1064
 TMatrixTUtils.cxx:1065
 TMatrixTUtils.cxx:1066
 TMatrixTUtils.cxx:1067
 TMatrixTUtils.cxx:1068
 TMatrixTUtils.cxx:1069
 TMatrixTUtils.cxx:1070
 TMatrixTUtils.cxx:1071
 TMatrixTUtils.cxx:1072
 TMatrixTUtils.cxx:1073
 TMatrixTUtils.cxx:1074
 TMatrixTUtils.cxx:1075
 TMatrixTUtils.cxx:1076
 TMatrixTUtils.cxx:1077
 TMatrixTUtils.cxx:1078
 TMatrixTUtils.cxx:1079
 TMatrixTUtils.cxx:1080
 TMatrixTUtils.cxx:1081
 TMatrixTUtils.cxx:1082
 TMatrixTUtils.cxx:1083
 TMatrixTUtils.cxx:1084
 TMatrixTUtils.cxx:1085
 TMatrixTUtils.cxx:1086
 TMatrixTUtils.cxx:1087
 TMatrixTUtils.cxx:1088
 TMatrixTUtils.cxx:1089
 TMatrixTUtils.cxx:1090
 TMatrixTUtils.cxx:1091
 TMatrixTUtils.cxx:1092
 TMatrixTUtils.cxx:1093
 TMatrixTUtils.cxx:1094
 TMatrixTUtils.cxx:1095
 TMatrixTUtils.cxx:1096
 TMatrixTUtils.cxx:1097
 TMatrixTUtils.cxx:1098
 TMatrixTUtils.cxx:1099
 TMatrixTUtils.cxx:1100
 TMatrixTUtils.cxx:1101
 TMatrixTUtils.cxx:1102
 TMatrixTUtils.cxx:1103
 TMatrixTUtils.cxx:1104
 TMatrixTUtils.cxx:1105
 TMatrixTUtils.cxx:1106
 TMatrixTUtils.cxx:1107
 TMatrixTUtils.cxx:1108
 TMatrixTUtils.cxx:1109
 TMatrixTUtils.cxx:1110
 TMatrixTUtils.cxx:1111
 TMatrixTUtils.cxx:1112
 TMatrixTUtils.cxx:1113
 TMatrixTUtils.cxx:1114
 TMatrixTUtils.cxx:1115
 TMatrixTUtils.cxx:1116
 TMatrixTUtils.cxx:1117
 TMatrixTUtils.cxx:1118
 TMatrixTUtils.cxx:1119
 TMatrixTUtils.cxx:1120
 TMatrixTUtils.cxx:1121
 TMatrixTUtils.cxx:1122
 TMatrixTUtils.cxx:1123
 TMatrixTUtils.cxx:1124
 TMatrixTUtils.cxx:1125
 TMatrixTUtils.cxx:1126
 TMatrixTUtils.cxx:1127
 TMatrixTUtils.cxx:1128
 TMatrixTUtils.cxx:1129
 TMatrixTUtils.cxx:1130
 TMatrixTUtils.cxx:1131
 TMatrixTUtils.cxx:1132
 TMatrixTUtils.cxx:1133
 TMatrixTUtils.cxx:1134
 TMatrixTUtils.cxx:1135
 TMatrixTUtils.cxx:1136
 TMatrixTUtils.cxx:1137
 TMatrixTUtils.cxx:1138
 TMatrixTUtils.cxx:1139
 TMatrixTUtils.cxx:1140
 TMatrixTUtils.cxx:1141
 TMatrixTUtils.cxx:1142
 TMatrixTUtils.cxx:1143
 TMatrixTUtils.cxx:1144
 TMatrixTUtils.cxx:1145
 TMatrixTUtils.cxx:1146
 TMatrixTUtils.cxx:1147
 TMatrixTUtils.cxx:1148
 TMatrixTUtils.cxx:1149
 TMatrixTUtils.cxx:1150
 TMatrixTUtils.cxx:1151
 TMatrixTUtils.cxx:1152
 TMatrixTUtils.cxx:1153
 TMatrixTUtils.cxx:1154
 TMatrixTUtils.cxx:1155
 TMatrixTUtils.cxx:1156
 TMatrixTUtils.cxx:1157
 TMatrixTUtils.cxx:1158
 TMatrixTUtils.cxx:1159
 TMatrixTUtils.cxx:1160
 TMatrixTUtils.cxx:1161
 TMatrixTUtils.cxx:1162
 TMatrixTUtils.cxx:1163
 TMatrixTUtils.cxx:1164
 TMatrixTUtils.cxx:1165
 TMatrixTUtils.cxx:1166
 TMatrixTUtils.cxx:1167
 TMatrixTUtils.cxx:1168
 TMatrixTUtils.cxx:1169
 TMatrixTUtils.cxx:1170
 TMatrixTUtils.cxx:1171
 TMatrixTUtils.cxx:1172
 TMatrixTUtils.cxx:1173
 TMatrixTUtils.cxx:1174
 TMatrixTUtils.cxx:1175
 TMatrixTUtils.cxx:1176
 TMatrixTUtils.cxx:1177
 TMatrixTUtils.cxx:1178
 TMatrixTUtils.cxx:1179
 TMatrixTUtils.cxx:1180
 TMatrixTUtils.cxx:1181
 TMatrixTUtils.cxx:1182
 TMatrixTUtils.cxx:1183
 TMatrixTUtils.cxx:1184
 TMatrixTUtils.cxx:1185
 TMatrixTUtils.cxx:1186
 TMatrixTUtils.cxx:1187
 TMatrixTUtils.cxx:1188
 TMatrixTUtils.cxx:1189
 TMatrixTUtils.cxx:1190
 TMatrixTUtils.cxx:1191
 TMatrixTUtils.cxx:1192
 TMatrixTUtils.cxx:1193
 TMatrixTUtils.cxx:1194
 TMatrixTUtils.cxx:1195
 TMatrixTUtils.cxx:1196
 TMatrixTUtils.cxx:1197
 TMatrixTUtils.cxx:1198
 TMatrixTUtils.cxx:1199
 TMatrixTUtils.cxx:1200
 TMatrixTUtils.cxx:1201
 TMatrixTUtils.cxx:1202
 TMatrixTUtils.cxx:1203
 TMatrixTUtils.cxx:1204
 TMatrixTUtils.cxx:1205
 TMatrixTUtils.cxx:1206
 TMatrixTUtils.cxx:1207
 TMatrixTUtils.cxx:1208
 TMatrixTUtils.cxx:1209
 TMatrixTUtils.cxx:1210
 TMatrixTUtils.cxx:1211
 TMatrixTUtils.cxx:1212
 TMatrixTUtils.cxx:1213
 TMatrixTUtils.cxx:1214
 TMatrixTUtils.cxx:1215
 TMatrixTUtils.cxx:1216
 TMatrixTUtils.cxx:1217
 TMatrixTUtils.cxx:1218
 TMatrixTUtils.cxx:1219
 TMatrixTUtils.cxx:1220
 TMatrixTUtils.cxx:1221
 TMatrixTUtils.cxx:1222
 TMatrixTUtils.cxx:1223
 TMatrixTUtils.cxx:1224
 TMatrixTUtils.cxx:1225
 TMatrixTUtils.cxx:1226
 TMatrixTUtils.cxx:1227
 TMatrixTUtils.cxx:1228
 TMatrixTUtils.cxx:1229
 TMatrixTUtils.cxx:1230
 TMatrixTUtils.cxx:1231
 TMatrixTUtils.cxx:1232
 TMatrixTUtils.cxx:1233
 TMatrixTUtils.cxx:1234
 TMatrixTUtils.cxx:1235
 TMatrixTUtils.cxx:1236
 TMatrixTUtils.cxx:1237
 TMatrixTUtils.cxx:1238
 TMatrixTUtils.cxx:1239
 TMatrixTUtils.cxx:1240
 TMatrixTUtils.cxx:1241
 TMatrixTUtils.cxx:1242
 TMatrixTUtils.cxx:1243
 TMatrixTUtils.cxx:1244
 TMatrixTUtils.cxx:1245
 TMatrixTUtils.cxx:1246
 TMatrixTUtils.cxx:1247
 TMatrixTUtils.cxx:1248
 TMatrixTUtils.cxx:1249
 TMatrixTUtils.cxx:1250
 TMatrixTUtils.cxx:1251
 TMatrixTUtils.cxx:1252
 TMatrixTUtils.cxx:1253
 TMatrixTUtils.cxx:1254
 TMatrixTUtils.cxx:1255
 TMatrixTUtils.cxx:1256
 TMatrixTUtils.cxx:1257
 TMatrixTUtils.cxx:1258
 TMatrixTUtils.cxx:1259
 TMatrixTUtils.cxx:1260
 TMatrixTUtils.cxx:1261
 TMatrixTUtils.cxx:1262
 TMatrixTUtils.cxx:1263
 TMatrixTUtils.cxx:1264
 TMatrixTUtils.cxx:1265
 TMatrixTUtils.cxx:1266
 TMatrixTUtils.cxx:1267
 TMatrixTUtils.cxx:1268
 TMatrixTUtils.cxx:1269
 TMatrixTUtils.cxx:1270
 TMatrixTUtils.cxx:1271
 TMatrixTUtils.cxx:1272
 TMatrixTUtils.cxx:1273
 TMatrixTUtils.cxx:1274
 TMatrixTUtils.cxx:1275
 TMatrixTUtils.cxx:1276
 TMatrixTUtils.cxx:1277
 TMatrixTUtils.cxx:1278
 TMatrixTUtils.cxx:1279
 TMatrixTUtils.cxx:1280
 TMatrixTUtils.cxx:1281
 TMatrixTUtils.cxx:1282
 TMatrixTUtils.cxx:1283
 TMatrixTUtils.cxx:1284
 TMatrixTUtils.cxx:1285
 TMatrixTUtils.cxx:1286
 TMatrixTUtils.cxx:1287
 TMatrixTUtils.cxx:1288
 TMatrixTUtils.cxx:1289
 TMatrixTUtils.cxx:1290
 TMatrixTUtils.cxx:1291
 TMatrixTUtils.cxx:1292
 TMatrixTUtils.cxx:1293
 TMatrixTUtils.cxx:1294
 TMatrixTUtils.cxx:1295
 TMatrixTUtils.cxx:1296
 TMatrixTUtils.cxx:1297
 TMatrixTUtils.cxx:1298
 TMatrixTUtils.cxx:1299
 TMatrixTUtils.cxx:1300
 TMatrixTUtils.cxx:1301
 TMatrixTUtils.cxx:1302
 TMatrixTUtils.cxx:1303
 TMatrixTUtils.cxx:1304
 TMatrixTUtils.cxx:1305
 TMatrixTUtils.cxx:1306
 TMatrixTUtils.cxx:1307
 TMatrixTUtils.cxx:1308
 TMatrixTUtils.cxx:1309
 TMatrixTUtils.cxx:1310
 TMatrixTUtils.cxx:1311
 TMatrixTUtils.cxx:1312
 TMatrixTUtils.cxx:1313
 TMatrixTUtils.cxx:1314
 TMatrixTUtils.cxx:1315
 TMatrixTUtils.cxx:1316
 TMatrixTUtils.cxx:1317
 TMatrixTUtils.cxx:1318
 TMatrixTUtils.cxx:1319
 TMatrixTUtils.cxx:1320
 TMatrixTUtils.cxx:1321
 TMatrixTUtils.cxx:1322
 TMatrixTUtils.cxx:1323
 TMatrixTUtils.cxx:1324
 TMatrixTUtils.cxx:1325
 TMatrixTUtils.cxx:1326
 TMatrixTUtils.cxx:1327
 TMatrixTUtils.cxx:1328
 TMatrixTUtils.cxx:1329
 TMatrixTUtils.cxx:1330
 TMatrixTUtils.cxx:1331
 TMatrixTUtils.cxx:1332
 TMatrixTUtils.cxx:1333
 TMatrixTUtils.cxx:1334
 TMatrixTUtils.cxx:1335
 TMatrixTUtils.cxx:1336
 TMatrixTUtils.cxx:1337
 TMatrixTUtils.cxx:1338
 TMatrixTUtils.cxx:1339
 TMatrixTUtils.cxx:1340
 TMatrixTUtils.cxx:1341
 TMatrixTUtils.cxx:1342
 TMatrixTUtils.cxx:1343
 TMatrixTUtils.cxx:1344
 TMatrixTUtils.cxx:1345
 TMatrixTUtils.cxx:1346
 TMatrixTUtils.cxx:1347
 TMatrixTUtils.cxx:1348
 TMatrixTUtils.cxx:1349
 TMatrixTUtils.cxx:1350
 TMatrixTUtils.cxx:1351
 TMatrixTUtils.cxx:1352
 TMatrixTUtils.cxx:1353
 TMatrixTUtils.cxx:1354
 TMatrixTUtils.cxx:1355
 TMatrixTUtils.cxx:1356
 TMatrixTUtils.cxx:1357
 TMatrixTUtils.cxx:1358
 TMatrixTUtils.cxx:1359
 TMatrixTUtils.cxx:1360
 TMatrixTUtils.cxx:1361
 TMatrixTUtils.cxx:1362
 TMatrixTUtils.cxx:1363
 TMatrixTUtils.cxx:1364
 TMatrixTUtils.cxx:1365
 TMatrixTUtils.cxx:1366
 TMatrixTUtils.cxx:1367
 TMatrixTUtils.cxx:1368
 TMatrixTUtils.cxx:1369
 TMatrixTUtils.cxx:1370
 TMatrixTUtils.cxx:1371
 TMatrixTUtils.cxx:1372
 TMatrixTUtils.cxx:1373
 TMatrixTUtils.cxx:1374
 TMatrixTUtils.cxx:1375
 TMatrixTUtils.cxx:1376
 TMatrixTUtils.cxx:1377
 TMatrixTUtils.cxx:1378
 TMatrixTUtils.cxx:1379
 TMatrixTUtils.cxx:1380
 TMatrixTUtils.cxx:1381
 TMatrixTUtils.cxx:1382
 TMatrixTUtils.cxx:1383
 TMatrixTUtils.cxx:1384
 TMatrixTUtils.cxx:1385
 TMatrixTUtils.cxx:1386
 TMatrixTUtils.cxx:1387
 TMatrixTUtils.cxx:1388
 TMatrixTUtils.cxx:1389
 TMatrixTUtils.cxx:1390
 TMatrixTUtils.cxx:1391
 TMatrixTUtils.cxx:1392
 TMatrixTUtils.cxx:1393
 TMatrixTUtils.cxx:1394
 TMatrixTUtils.cxx:1395
 TMatrixTUtils.cxx:1396
 TMatrixTUtils.cxx:1397
 TMatrixTUtils.cxx:1398
 TMatrixTUtils.cxx:1399
 TMatrixTUtils.cxx:1400
 TMatrixTUtils.cxx:1401
 TMatrixTUtils.cxx:1402
 TMatrixTUtils.cxx:1403
 TMatrixTUtils.cxx:1404
 TMatrixTUtils.cxx:1405
 TMatrixTUtils.cxx:1406
 TMatrixTUtils.cxx:1407
 TMatrixTUtils.cxx:1408
 TMatrixTUtils.cxx:1409
 TMatrixTUtils.cxx:1410
 TMatrixTUtils.cxx:1411
 TMatrixTUtils.cxx:1412
 TMatrixTUtils.cxx:1413
 TMatrixTUtils.cxx:1414
 TMatrixTUtils.cxx:1415
 TMatrixTUtils.cxx:1416
 TMatrixTUtils.cxx:1417
 TMatrixTUtils.cxx:1418
 TMatrixTUtils.cxx:1419
 TMatrixTUtils.cxx:1420
 TMatrixTUtils.cxx:1421
 TMatrixTUtils.cxx:1422
 TMatrixTUtils.cxx:1423
 TMatrixTUtils.cxx:1424
 TMatrixTUtils.cxx:1425
 TMatrixTUtils.cxx:1426
 TMatrixTUtils.cxx:1427
 TMatrixTUtils.cxx:1428
 TMatrixTUtils.cxx:1429
 TMatrixTUtils.cxx:1430
 TMatrixTUtils.cxx:1431
 TMatrixTUtils.cxx:1432
 TMatrixTUtils.cxx:1433
 TMatrixTUtils.cxx:1434
 TMatrixTUtils.cxx:1435
 TMatrixTUtils.cxx:1436
 TMatrixTUtils.cxx:1437
 TMatrixTUtils.cxx:1438
 TMatrixTUtils.cxx:1439
 TMatrixTUtils.cxx:1440
 TMatrixTUtils.cxx:1441
 TMatrixTUtils.cxx:1442
 TMatrixTUtils.cxx:1443
 TMatrixTUtils.cxx:1444
 TMatrixTUtils.cxx:1445
 TMatrixTUtils.cxx:1446
 TMatrixTUtils.cxx:1447
 TMatrixTUtils.cxx:1448
 TMatrixTUtils.cxx:1449
 TMatrixTUtils.cxx:1450
 TMatrixTUtils.cxx:1451
 TMatrixTUtils.cxx:1452
 TMatrixTUtils.cxx:1453
 TMatrixTUtils.cxx:1454
 TMatrixTUtils.cxx:1455
 TMatrixTUtils.cxx:1456
 TMatrixTUtils.cxx:1457
 TMatrixTUtils.cxx:1458
 TMatrixTUtils.cxx:1459
 TMatrixTUtils.cxx:1460
 TMatrixTUtils.cxx:1461
 TMatrixTUtils.cxx:1462
 TMatrixTUtils.cxx:1463
 TMatrixTUtils.cxx:1464
 TMatrixTUtils.cxx:1465
 TMatrixTUtils.cxx:1466
 TMatrixTUtils.cxx:1467
 TMatrixTUtils.cxx:1468
 TMatrixTUtils.cxx:1469
 TMatrixTUtils.cxx:1470
 TMatrixTUtils.cxx:1471
 TMatrixTUtils.cxx:1472
 TMatrixTUtils.cxx:1473
 TMatrixTUtils.cxx:1474
 TMatrixTUtils.cxx:1475
 TMatrixTUtils.cxx:1476
 TMatrixTUtils.cxx:1477
 TMatrixTUtils.cxx:1478
 TMatrixTUtils.cxx:1479
 TMatrixTUtils.cxx:1480
 TMatrixTUtils.cxx:1481
 TMatrixTUtils.cxx:1482
 TMatrixTUtils.cxx:1483
 TMatrixTUtils.cxx:1484
 TMatrixTUtils.cxx:1485
 TMatrixTUtils.cxx:1486
 TMatrixTUtils.cxx:1487
 TMatrixTUtils.cxx:1488
 TMatrixTUtils.cxx:1489
 TMatrixTUtils.cxx:1490
 TMatrixTUtils.cxx:1491
 TMatrixTUtils.cxx:1492
 TMatrixTUtils.cxx:1493
 TMatrixTUtils.cxx:1494
 TMatrixTUtils.cxx:1495
 TMatrixTUtils.cxx:1496
 TMatrixTUtils.cxx:1497
 TMatrixTUtils.cxx:1498
 TMatrixTUtils.cxx:1499
 TMatrixTUtils.cxx:1500
 TMatrixTUtils.cxx:1501
 TMatrixTUtils.cxx:1502
 TMatrixTUtils.cxx:1503
 TMatrixTUtils.cxx:1504
 TMatrixTUtils.cxx:1505
 TMatrixTUtils.cxx:1506
 TMatrixTUtils.cxx:1507
 TMatrixTUtils.cxx:1508
 TMatrixTUtils.cxx:1509
 TMatrixTUtils.cxx:1510
 TMatrixTUtils.cxx:1511
 TMatrixTUtils.cxx:1512
 TMatrixTUtils.cxx:1513
 TMatrixTUtils.cxx:1514
 TMatrixTUtils.cxx:1515
 TMatrixTUtils.cxx:1516
 TMatrixTUtils.cxx:1517
 TMatrixTUtils.cxx:1518
 TMatrixTUtils.cxx:1519
 TMatrixTUtils.cxx:1520
 TMatrixTUtils.cxx:1521
 TMatrixTUtils.cxx:1522
 TMatrixTUtils.cxx:1523
 TMatrixTUtils.cxx:1524
 TMatrixTUtils.cxx:1525
 TMatrixTUtils.cxx:1526
 TMatrixTUtils.cxx:1527
 TMatrixTUtils.cxx:1528
 TMatrixTUtils.cxx:1529
 TMatrixTUtils.cxx:1530
 TMatrixTUtils.cxx:1531
 TMatrixTUtils.cxx:1532
 TMatrixTUtils.cxx:1533
 TMatrixTUtils.cxx:1534
 TMatrixTUtils.cxx:1535
 TMatrixTUtils.cxx:1536
 TMatrixTUtils.cxx:1537
 TMatrixTUtils.cxx:1538
 TMatrixTUtils.cxx:1539
 TMatrixTUtils.cxx:1540
 TMatrixTUtils.cxx:1541
 TMatrixTUtils.cxx:1542
 TMatrixTUtils.cxx:1543
 TMatrixTUtils.cxx:1544
 TMatrixTUtils.cxx:1545
 TMatrixTUtils.cxx:1546
 TMatrixTUtils.cxx:1547
 TMatrixTUtils.cxx:1548
 TMatrixTUtils.cxx:1549
 TMatrixTUtils.cxx:1550
 TMatrixTUtils.cxx:1551
 TMatrixTUtils.cxx:1552
 TMatrixTUtils.cxx:1553
 TMatrixTUtils.cxx:1554
 TMatrixTUtils.cxx:1555
 TMatrixTUtils.cxx:1556
 TMatrixTUtils.cxx:1557
 TMatrixTUtils.cxx:1558
 TMatrixTUtils.cxx:1559
 TMatrixTUtils.cxx:1560
 TMatrixTUtils.cxx:1561
 TMatrixTUtils.cxx:1562
 TMatrixTUtils.cxx:1563
 TMatrixTUtils.cxx:1564
 TMatrixTUtils.cxx:1565
 TMatrixTUtils.cxx:1566
 TMatrixTUtils.cxx:1567
 TMatrixTUtils.cxx:1568
 TMatrixTUtils.cxx:1569
 TMatrixTUtils.cxx:1570
 TMatrixTUtils.cxx:1571
 TMatrixTUtils.cxx:1572
 TMatrixTUtils.cxx:1573
 TMatrixTUtils.cxx:1574
 TMatrixTUtils.cxx:1575
 TMatrixTUtils.cxx:1576
 TMatrixTUtils.cxx:1577
 TMatrixTUtils.cxx:1578
 TMatrixTUtils.cxx:1579
 TMatrixTUtils.cxx:1580
 TMatrixTUtils.cxx:1581
 TMatrixTUtils.cxx:1582
 TMatrixTUtils.cxx:1583
 TMatrixTUtils.cxx:1584
 TMatrixTUtils.cxx:1585
 TMatrixTUtils.cxx:1586
 TMatrixTUtils.cxx:1587
 TMatrixTUtils.cxx:1588
 TMatrixTUtils.cxx:1589
 TMatrixTUtils.cxx:1590
 TMatrixTUtils.cxx:1591
 TMatrixTUtils.cxx:1592
 TMatrixTUtils.cxx:1593
 TMatrixTUtils.cxx:1594
 TMatrixTUtils.cxx:1595
 TMatrixTUtils.cxx:1596
 TMatrixTUtils.cxx:1597
 TMatrixTUtils.cxx:1598
 TMatrixTUtils.cxx:1599
 TMatrixTUtils.cxx:1600
 TMatrixTUtils.cxx:1601
 TMatrixTUtils.cxx:1602
 TMatrixTUtils.cxx:1603
 TMatrixTUtils.cxx:1604
 TMatrixTUtils.cxx:1605
 TMatrixTUtils.cxx:1606
 TMatrixTUtils.cxx:1607
 TMatrixTUtils.cxx:1608
 TMatrixTUtils.cxx:1609
 TMatrixTUtils.cxx:1610
 TMatrixTUtils.cxx:1611
 TMatrixTUtils.cxx:1612
 TMatrixTUtils.cxx:1613
 TMatrixTUtils.cxx:1614
 TMatrixTUtils.cxx:1615
 TMatrixTUtils.cxx:1616
 TMatrixTUtils.cxx:1617
 TMatrixTUtils.cxx:1618
 TMatrixTUtils.cxx:1619
 TMatrixTUtils.cxx:1620
 TMatrixTUtils.cxx:1621
 TMatrixTUtils.cxx:1622
 TMatrixTUtils.cxx:1623
 TMatrixTUtils.cxx:1624
 TMatrixTUtils.cxx:1625
 TMatrixTUtils.cxx:1626
 TMatrixTUtils.cxx:1627
 TMatrixTUtils.cxx:1628
 TMatrixTUtils.cxx:1629
 TMatrixTUtils.cxx:1630
 TMatrixTUtils.cxx:1631
 TMatrixTUtils.cxx:1632
 TMatrixTUtils.cxx:1633
 TMatrixTUtils.cxx:1634
 TMatrixTUtils.cxx:1635
 TMatrixTUtils.cxx:1636
 TMatrixTUtils.cxx:1637
 TMatrixTUtils.cxx:1638
 TMatrixTUtils.cxx:1639
 TMatrixTUtils.cxx:1640
 TMatrixTUtils.cxx:1641
 TMatrixTUtils.cxx:1642
 TMatrixTUtils.cxx:1643
 TMatrixTUtils.cxx:1644
 TMatrixTUtils.cxx:1645
 TMatrixTUtils.cxx:1646
 TMatrixTUtils.cxx:1647
 TMatrixTUtils.cxx:1648
 TMatrixTUtils.cxx:1649
 TMatrixTUtils.cxx:1650
 TMatrixTUtils.cxx:1651
 TMatrixTUtils.cxx:1652
 TMatrixTUtils.cxx:1653
 TMatrixTUtils.cxx:1654
 TMatrixTUtils.cxx:1655
 TMatrixTUtils.cxx:1656
 TMatrixTUtils.cxx:1657
 TMatrixTUtils.cxx:1658
 TMatrixTUtils.cxx:1659
 TMatrixTUtils.cxx:1660
 TMatrixTUtils.cxx:1661
 TMatrixTUtils.cxx:1662
 TMatrixTUtils.cxx:1663
 TMatrixTUtils.cxx:1664
 TMatrixTUtils.cxx:1665
 TMatrixTUtils.cxx:1666
 TMatrixTUtils.cxx:1667
 TMatrixTUtils.cxx:1668
 TMatrixTUtils.cxx:1669
 TMatrixTUtils.cxx:1670
 TMatrixTUtils.cxx:1671
 TMatrixTUtils.cxx:1672
 TMatrixTUtils.cxx:1673
 TMatrixTUtils.cxx:1674
 TMatrixTUtils.cxx:1675
 TMatrixTUtils.cxx:1676
 TMatrixTUtils.cxx:1677
 TMatrixTUtils.cxx:1678
 TMatrixTUtils.cxx:1679
 TMatrixTUtils.cxx:1680
 TMatrixTUtils.cxx:1681
 TMatrixTUtils.cxx:1682
 TMatrixTUtils.cxx:1683
 TMatrixTUtils.cxx:1684
 TMatrixTUtils.cxx:1685
 TMatrixTUtils.cxx:1686
 TMatrixTUtils.cxx:1687
 TMatrixTUtils.cxx:1688
 TMatrixTUtils.cxx:1689
 TMatrixTUtils.cxx:1690
 TMatrixTUtils.cxx:1691
 TMatrixTUtils.cxx:1692
 TMatrixTUtils.cxx:1693
 TMatrixTUtils.cxx:1694
 TMatrixTUtils.cxx:1695
 TMatrixTUtils.cxx:1696
 TMatrixTUtils.cxx:1697
 TMatrixTUtils.cxx:1698
 TMatrixTUtils.cxx:1699
 TMatrixTUtils.cxx:1700
 TMatrixTUtils.cxx:1701
 TMatrixTUtils.cxx:1702
 TMatrixTUtils.cxx:1703
 TMatrixTUtils.cxx:1704
 TMatrixTUtils.cxx:1705
 TMatrixTUtils.cxx:1706
 TMatrixTUtils.cxx:1707
 TMatrixTUtils.cxx:1708
 TMatrixTUtils.cxx:1709
 TMatrixTUtils.cxx:1710
 TMatrixTUtils.cxx:1711
 TMatrixTUtils.cxx:1712
 TMatrixTUtils.cxx:1713
 TMatrixTUtils.cxx:1714
 TMatrixTUtils.cxx:1715
 TMatrixTUtils.cxx:1716
 TMatrixTUtils.cxx:1717
 TMatrixTUtils.cxx:1718
 TMatrixTUtils.cxx:1719
 TMatrixTUtils.cxx:1720
 TMatrixTUtils.cxx:1721
 TMatrixTUtils.cxx:1722
 TMatrixTUtils.cxx:1723
 TMatrixTUtils.cxx:1724
 TMatrixTUtils.cxx:1725
 TMatrixTUtils.cxx:1726
 TMatrixTUtils.cxx:1727
 TMatrixTUtils.cxx:1728
 TMatrixTUtils.cxx:1729
 TMatrixTUtils.cxx:1730
 TMatrixTUtils.cxx:1731
 TMatrixTUtils.cxx:1732
 TMatrixTUtils.cxx:1733
 TMatrixTUtils.cxx:1734
 TMatrixTUtils.cxx:1735
 TMatrixTUtils.cxx:1736
 TMatrixTUtils.cxx:1737
 TMatrixTUtils.cxx:1738
 TMatrixTUtils.cxx:1739
 TMatrixTUtils.cxx:1740
 TMatrixTUtils.cxx:1741
 TMatrixTUtils.cxx:1742
 TMatrixTUtils.cxx:1743
 TMatrixTUtils.cxx:1744
 TMatrixTUtils.cxx:1745
 TMatrixTUtils.cxx:1746
 TMatrixTUtils.cxx:1747
 TMatrixTUtils.cxx:1748
 TMatrixTUtils.cxx:1749
 TMatrixTUtils.cxx:1750
 TMatrixTUtils.cxx:1751
 TMatrixTUtils.cxx:1752
 TMatrixTUtils.cxx:1753
 TMatrixTUtils.cxx:1754
 TMatrixTUtils.cxx:1755
 TMatrixTUtils.cxx:1756
 TMatrixTUtils.cxx:1757
 TMatrixTUtils.cxx:1758
 TMatrixTUtils.cxx:1759
 TMatrixTUtils.cxx:1760
 TMatrixTUtils.cxx:1761
 TMatrixTUtils.cxx:1762
 TMatrixTUtils.cxx:1763
 TMatrixTUtils.cxx:1764
 TMatrixTUtils.cxx:1765
 TMatrixTUtils.cxx:1766
 TMatrixTUtils.cxx:1767
 TMatrixTUtils.cxx:1768
 TMatrixTUtils.cxx:1769
 TMatrixTUtils.cxx:1770
 TMatrixTUtils.cxx:1771
 TMatrixTUtils.cxx:1772
 TMatrixTUtils.cxx:1773
 TMatrixTUtils.cxx:1774
 TMatrixTUtils.cxx:1775
 TMatrixTUtils.cxx:1776
 TMatrixTUtils.cxx:1777
 TMatrixTUtils.cxx:1778
 TMatrixTUtils.cxx:1779
 TMatrixTUtils.cxx:1780
 TMatrixTUtils.cxx:1781
 TMatrixTUtils.cxx:1782
 TMatrixTUtils.cxx:1783
 TMatrixTUtils.cxx:1784
 TMatrixTUtils.cxx:1785
 TMatrixTUtils.cxx:1786
 TMatrixTUtils.cxx:1787
 TMatrixTUtils.cxx:1788
 TMatrixTUtils.cxx:1789
 TMatrixTUtils.cxx:1790
 TMatrixTUtils.cxx:1791
 TMatrixTUtils.cxx:1792
 TMatrixTUtils.cxx:1793
 TMatrixTUtils.cxx:1794
 TMatrixTUtils.cxx:1795
 TMatrixTUtils.cxx:1796
 TMatrixTUtils.cxx:1797
 TMatrixTUtils.cxx:1798
 TMatrixTUtils.cxx:1799
 TMatrixTUtils.cxx:1800
 TMatrixTUtils.cxx:1801
 TMatrixTUtils.cxx:1802
 TMatrixTUtils.cxx:1803
 TMatrixTUtils.cxx:1804
 TMatrixTUtils.cxx:1805
 TMatrixTUtils.cxx:1806
 TMatrixTUtils.cxx:1807
 TMatrixTUtils.cxx:1808
 TMatrixTUtils.cxx:1809
 TMatrixTUtils.cxx:1810
 TMatrixTUtils.cxx:1811
 TMatrixTUtils.cxx:1812
 TMatrixTUtils.cxx:1813
 TMatrixTUtils.cxx:1814
 TMatrixTUtils.cxx:1815
 TMatrixTUtils.cxx:1816
 TMatrixTUtils.cxx:1817
 TMatrixTUtils.cxx:1818
 TMatrixTUtils.cxx:1819
 TMatrixTUtils.cxx:1820
 TMatrixTUtils.cxx:1821
 TMatrixTUtils.cxx:1822
 TMatrixTUtils.cxx:1823
 TMatrixTUtils.cxx:1824
 TMatrixTUtils.cxx:1825
 TMatrixTUtils.cxx:1826
 TMatrixTUtils.cxx:1827
 TMatrixTUtils.cxx:1828
 TMatrixTUtils.cxx:1829
 TMatrixTUtils.cxx:1830
 TMatrixTUtils.cxx:1831
 TMatrixTUtils.cxx:1832
 TMatrixTUtils.cxx:1833
 TMatrixTUtils.cxx:1834
 TMatrixTUtils.cxx:1835
 TMatrixTUtils.cxx:1836
 TMatrixTUtils.cxx:1837
 TMatrixTUtils.cxx:1838
 TMatrixTUtils.cxx:1839
 TMatrixTUtils.cxx:1840
 TMatrixTUtils.cxx:1841
 TMatrixTUtils.cxx:1842
 TMatrixTUtils.cxx:1843
 TMatrixTUtils.cxx:1844
 TMatrixTUtils.cxx:1845
 TMatrixTUtils.cxx:1846
 TMatrixTUtils.cxx:1847
 TMatrixTUtils.cxx:1848
 TMatrixTUtils.cxx:1849
 TMatrixTUtils.cxx:1850
 TMatrixTUtils.cxx:1851
 TMatrixTUtils.cxx:1852
 TMatrixTUtils.cxx:1853
 TMatrixTUtils.cxx:1854
 TMatrixTUtils.cxx:1855
 TMatrixTUtils.cxx:1856
 TMatrixTUtils.cxx:1857
 TMatrixTUtils.cxx:1858
 TMatrixTUtils.cxx:1859
 TMatrixTUtils.cxx:1860
 TMatrixTUtils.cxx:1861
 TMatrixTUtils.cxx:1862
 TMatrixTUtils.cxx:1863
 TMatrixTUtils.cxx:1864
 TMatrixTUtils.cxx:1865
 TMatrixTUtils.cxx:1866
 TMatrixTUtils.cxx:1867
 TMatrixTUtils.cxx:1868
 TMatrixTUtils.cxx:1869
 TMatrixTUtils.cxx:1870
 TMatrixTUtils.cxx:1871
 TMatrixTUtils.cxx:1872
 TMatrixTUtils.cxx:1873
 TMatrixTUtils.cxx:1874
 TMatrixTUtils.cxx:1875
 TMatrixTUtils.cxx:1876
 TMatrixTUtils.cxx:1877
 TMatrixTUtils.cxx:1878
 TMatrixTUtils.cxx:1879
 TMatrixTUtils.cxx:1880
 TMatrixTUtils.cxx:1881
 TMatrixTUtils.cxx:1882
 TMatrixTUtils.cxx:1883
 TMatrixTUtils.cxx:1884
 TMatrixTUtils.cxx:1885
 TMatrixTUtils.cxx:1886
 TMatrixTUtils.cxx:1887
 TMatrixTUtils.cxx:1888
 TMatrixTUtils.cxx:1889