ROOT logo
// @(#)root/matrix:$Id: TMatrixT.cxx 35998 2010-10-01 12:47:38Z brun $
// 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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixT                                                             //
//                                                                      //
// Template class of a general matrix in the linear algebra package     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <typeinfo>

#include "TMatrixT.h"
#include "TMatrixTSym.h"
#include "TMatrixTLazy.h"
#include "TMatrixTCramerInv.h"
#include "TDecompLU.h"
#include "TMatrixDEigen.h"
#include "TClass.h"
#include "TMath.h"

#ifndef R__ALPHA
templateClassImp(TMatrixT)
#endif
//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(Int_t nrows,Int_t ncols)
{
// Constructor for (nrows x ncols) matrix

   Allocate(nrows,ncols,0,0,1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)
{
// Constructor for ([row_lwb..row_upb] x [col_lwb..col_upb]) matrix

   Allocate(row_upb-row_lwb+1,col_upb-col_lwb+1,row_lwb,col_lwb,1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(Int_t no_rows,Int_t no_cols,const Element *elements,Option_t *option)
{
// option="F": array elements contains the matrix stored column-wise
//             like in Fortran, so a[i,j] = elements[i+no_rows*j],
// else        it is supposed that array elements are stored row-wise
//             a[i,j] = elements[i*no_cols+j]
//
// array elements are copied

   Allocate(no_rows,no_cols);
   TMatrixTBase<Element>::SetMatrixArray(elements,option);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                            const Element *elements,Option_t *option)
{
// array elements are copied

   Allocate(row_upb-row_lwb+1,col_upb-col_lwb+1,row_lwb,col_lwb);
   TMatrixTBase<Element>::SetMatrixArray(elements,option);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixT<Element> &another) : TMatrixTBase<Element>(another)
{
// Copy constructor

   R__ASSERT(another.IsValid());
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixTSym<Element> &another)
{
// Copy constructor of a symmetric matrix

   R__ASSERT(another.IsValid());
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixTSparse<Element> &another)
{
// Copy constructor of a sparse matrix

   R__ASSERT(another.IsValid());
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(EMatrixCreatorsOp1 op,const TMatrixT<Element> &prototype)
{
// Constructor of matrix applying a specific operation to the prototype.
// Example: TMatrixT<Element> a(10,12); ...; TMatrixT<Element> b(TMatrixT::kTransposed, a);
// Supported operations are: kZero, kUnit, kTransposed, kInverted and kAtA.

   R__ASSERT(prototype.IsValid());

   switch(op) {
      case kZero:
         Allocate(prototype.GetNrows(),prototype.GetNcols(),
                  prototype.GetRowLwb(),prototype.GetColLwb(),1);
         break;

      case kUnit:
         Allocate(prototype.GetNrows(),prototype.GetNcols(),
                  prototype.GetRowLwb(),prototype.GetColLwb(),1);
         this->UnitMatrix();
         break;

      case kTransposed:
         Allocate(prototype.GetNcols(), prototype.GetNrows(),
                  prototype.GetColLwb(),prototype.GetRowLwb());
         Transpose(prototype);
         break;

      case kInverted:
      {
         Allocate(prototype.GetNrows(),prototype.GetNcols(),
                  prototype.GetRowLwb(),prototype.GetColLwb(),1);
         *this = prototype;
         // Since the user can not control the tolerance of this newly created matrix
         // we put it to the smallest possible number
         const Element oldTol = this->SetTol(std::numeric_limits<Element>::min());
         this->Invert();
         this->SetTol(oldTol);
         break;
      }

      case kAtA:
         Allocate(prototype.GetNcols(),prototype.GetNcols(),prototype.GetColLwb(),prototype.GetColLwb(),1);
         TMult(prototype,prototype);
         break;

      default:
         Error("TMatrixT(EMatrixCreatorOp1)", "operation %d not yet implemented", op);
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixT<Element> &a,EMatrixCreatorsOp2 op,const TMatrixT<Element> &b)
{
// Constructor of matrix applying a specific operation to two prototypes.
// Example: TMatrixT<Element> a(10,12), b(12,5); ...; TMatrixT<Element> c(a, TMatrixT::kMult, b);
// Supported operations are: kMult (a*b), kTransposeMult (a'*b), kInvMult (a^(-1)*b)

   R__ASSERT(a.IsValid());
   R__ASSERT(b.IsValid());

   switch(op) {
      case kMult:
         Allocate(a.GetNrows(),b.GetNcols(),a.GetRowLwb(),b.GetColLwb(),1);
         Mult(a,b);
         break;

      case kTransposeMult:
         Allocate(a.GetNcols(),b.GetNcols(),a.GetColLwb(),b.GetColLwb(),1);
         TMult(a,b);
         break;

      case kMultTranspose:
         Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1);
         MultT(a,b);
         break;

      case kInvMult:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         *this = a;
         const Element oldTol = this->SetTol(std::numeric_limits<Element>::min());
         this->Invert();
         this->SetTol(oldTol);
         *this *= b;
         break;
      }

      case kPlus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Plus(a,b);
         break;
      }

      case kMinus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Minus(a,b);
         break;
      }

      default:
         Error("TMatrixT(EMatrixCreatorOp2)", "operation %d not yet implemented", op);
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixT<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b)
{
// Constructor of matrix applying a specific operation to two prototypes.
// Example: TMatrixT<Element> a(10,12), b(12,5); ...; TMatrixT<Element> c(a, TMatrixT::kMult, b);
// Supported operations are: kMult (a*b), kTransposeMult (a'*b), kInvMult (a^(-1)*b)

   R__ASSERT(a.IsValid());
   R__ASSERT(b.IsValid());

   switch(op) {
      case kMult:
         Allocate(a.GetNrows(),b.GetNcols(),a.GetRowLwb(),b.GetColLwb(),1);
         Mult(a,b);
         break;

      case kTransposeMult:
         Allocate(a.GetNcols(),b.GetNcols(),a.GetColLwb(),b.GetColLwb(),1);
         TMult(a,b);
         break;

      case kMultTranspose:
         Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1);
         MultT(a,b);
         break;

      case kInvMult:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         *this = a;
         const Element oldTol = this->SetTol(std::numeric_limits<Element>::min());
         this->Invert();
         this->SetTol(oldTol);
         *this *= b;
         break;
      }

      case kPlus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Plus(a,b);
         break;
      }

      case kMinus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Minus(a,b);
         break;
      }

      default:
         Error("TMatrixT(EMatrixCreatorOp2)", "operation %d not yet implemented", op);
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixTSym<Element> &a,EMatrixCreatorsOp2 op,const TMatrixT<Element> &b)
{
// Constructor of matrix applying a specific operation to two prototypes.
// Example: TMatrixT<Element> a(10,12), b(12,5); ...; TMatrixT<Element> c(a, TMatrixT::kMult, b);
// Supported operations are: kMult (a*b), kTransposeMult (a'*b), kInvMult (a^(-1)*b)

   R__ASSERT(a.IsValid());
   R__ASSERT(b.IsValid());

   switch(op) {
      case kMult:
         Allocate(a.GetNrows(),b.GetNcols(),a.GetRowLwb(),b.GetColLwb(),1);
         Mult(a,b);
         break;

      case kTransposeMult:
         Allocate(a.GetNcols(),b.GetNcols(),a.GetColLwb(),b.GetColLwb(),1);
         TMult(a,b);
         break;

      case kMultTranspose:
         Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1);
         MultT(a,b);
         break;

      case kInvMult:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         *this = a;
         const Element oldTol = this->SetTol(std::numeric_limits<Element>::min());
         this->Invert();
         this->SetTol(oldTol);
         *this *= b;
         break;
      }

      case kPlus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Plus(a,b);
         break;
      }

      case kMinus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Minus(a,b);
         break;
      }

      default:
         Error("TMatrixT(EMatrixCreatorOp2)", "operation %d not yet implemented", op);
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixTSym<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b)
{
// Constructor of matrix applying a specific operation to two prototypes.
// Example: TMatrixT<Element> a(10,12), b(12,5); ...; TMatrixT<Element> c(a, TMatrixT::kMult, b);
// Supported operations are: kMult (a*b), kTransposeMult (a'*b), kInvMult (a^(-1)*b)

   R__ASSERT(a.IsValid());
   R__ASSERT(b.IsValid());

   switch(op) {
      case kMult:
         Allocate(a.GetNrows(),b.GetNcols(),a.GetRowLwb(),b.GetColLwb(),1);
         Mult(a,b);
         break;

      case kTransposeMult:
         Allocate(a.GetNcols(),b.GetNcols(),a.GetColLwb(),b.GetColLwb(),1);
         TMult(a,b);
         break;

      case kMultTranspose:
         Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1);
         MultT(a,b);
         break;

      case kInvMult:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         *this = a;
         const Element oldTol = this->SetTol(std::numeric_limits<Element>::min());
         this->Invert();
         this->SetTol(oldTol);
         *this *= b;
         break;
      }

      case kPlus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Plus(*dynamic_cast<const TMatrixT<Element> *>(&a),b);
         break;
      }

      case kMinus:
      {
         Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb(),1);
         Minus(*dynamic_cast<const TMatrixT<Element> *>(&a),b);
         break;
      }

      default:
         Error("TMatrixT(EMatrixCreatorOp2)", "operation %d not yet implemented", op);
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element>::TMatrixT(const TMatrixTLazy<Element> &lazy_constructor)
{
// Constructor using the TMatrixTLazy class

   Allocate(lazy_constructor.GetRowUpb()-lazy_constructor.GetRowLwb()+1,
            lazy_constructor.GetColUpb()-lazy_constructor.GetColLwb()+1,
            lazy_constructor.GetRowLwb(),lazy_constructor.GetColLwb(),1);
   lazy_constructor.FillIn(*this);
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Delete_m(Int_t size,Element *&m)
{
// Delete data pointer m, if it was assigned on the heap

   if (m) {
      if (size > this->kSizeMax)
         delete [] m;
      m = 0;
   }
}

//______________________________________________________________________________
template<class Element>
Element* TMatrixT<Element>::New_m(Int_t size)
{
// Return data pointer . if requested size <= kSizeMax, assign pointer
// to the stack space

   if (size == 0) return 0;
   else {
      if ( size <= this->kSizeMax )
         return fDataStack;
      else {
         Element *heap = new Element[size];
         return heap;
      }
   }
}

//______________________________________________________________________________
template<class Element>
Int_t TMatrixT<Element>::Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
                                  Int_t newSize,Int_t oldSize)
{
// Copy copySize doubles from *oldp to *newp . However take care of the
// situation where both pointers are assigned to the same stack space

   if (copySize == 0 || oldp == newp)
      return 0;
   else {
      if ( newSize <= this->kSizeMax && oldSize <= this->kSizeMax ) {
         // both pointers are inside fDataStack, be careful with copy direction !
         if (newp > oldp) {
            for (Int_t i = copySize-1; i >= 0; i--)
               newp[i] = oldp[i];
         } else {
            for (Int_t i = 0; i < copySize; i++)
               newp[i] = oldp[i];
         }
      }
      else
         memcpy(newp,oldp,copySize*sizeof(Element));
   }
   return 0;
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Allocate(Int_t no_rows,Int_t no_cols,Int_t row_lwb,Int_t col_lwb,
                                 Int_t init,Int_t /*nr_nonzeros*/)
{
// Allocate new matrix. Arguments are number of rows, columns, row
// lowerbound (0 default) and column lowerbound (0 default).

   this->fIsOwner = kTRUE;
   this->fTol     = std::numeric_limits<Element>::epsilon();
   fElements      = 0;
   this->fNrows   = 0;
   this->fNcols   = 0;
   this->fRowLwb  = 0;
   this->fColLwb  = 0;
   this->fNelems  = 0;

   if (no_rows < 0 || no_cols < 0)
   {
      Error("Allocate","no_rows=%d no_cols=%d",no_rows,no_cols);
      this->Invalidate();
      return;
   }

   this->MakeValid();
   this->fNrows   = no_rows;
   this->fNcols   = no_cols;
   this->fRowLwb  = row_lwb;
   this->fColLwb  = col_lwb;
   this->fNelems  = this->fNrows*this->fNcols;

   if (this->fNelems > 0) {
      fElements = New_m(this->fNelems);
      if (init)
         memset(fElements,0,this->fNelems*sizeof(Element));
   } else
     fElements = 0;
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Plus(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
{
// General matrix summation. Create a matrix C such that C = A + B.

   if (gMatrixCheck) {
      if (!AreCompatible(a,b)) {
         Error("Plus","matrices not compatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Plus","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Plus","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

   const Element *       ap      = a.GetMatrixArray();
   const Element *       bp      = b.GetMatrixArray();
         Element *       cp      = this->GetMatrixArray();
   const Element * const cp_last = cp+this->fNelems;

   while (cp < cp_last) {
       *cp = *ap++ + *bp++;
       cp++;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Plus(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
{
// General matrix summation. Create a matrix C such that C = A + B.

   if (gMatrixCheck) {
      if (!AreCompatible(a,b)) {
         Error("Plus","matrices not compatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Plus","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Plus","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

   const Element *       ap      = a.GetMatrixArray();
   const Element *       bp      = b.GetMatrixArray();
         Element *       cp      = this->GetMatrixArray();
   const Element * const cp_last = cp+this->fNelems;

   while (cp < cp_last) {
       *cp = *ap++ + *bp++;
       cp++;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Minus(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
{
// General matrix summation. Create a matrix C such that C = A - B.

   if (gMatrixCheck) {
      if (!AreCompatible(a,b)) {
         Error("Minus","matrices not compatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Minus","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Minus","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

   const Element *       ap      = a.GetMatrixArray();
   const Element *       bp      = b.GetMatrixArray();
         Element *       cp      = this->GetMatrixArray();
   const Element * const cp_last = cp+this->fNelems;

   while (cp < cp_last) {
      *cp = *ap++ - *bp++;
      cp++;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Minus(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
{
// General matrix summation. Create a matrix C such that C = A - B.

   if (gMatrixCheck) {
      if (!AreCompatible(a,b)) {
         Error("Minus","matrices not compatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Minus","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Minus","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

   const Element *       ap      = a.GetMatrixArray();
   const Element *       bp      = b.GetMatrixArray();
         Element *       cp      = this->GetMatrixArray();
   const Element * const cp_last = cp+this->fNelems;

   while (cp < cp_last) {
       *cp = *ap++ - *bp++;
       cp++;
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Mult(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
{
// General matrix multiplication. Create a matrix C such that C = A * B.

   if (gMatrixCheck) {
      if (a.GetNcols() != b.GetNrows() || a.GetColLwb() != b.GetRowLwb()) {
         Error("Mult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasNoTrans,CblasNoTrans,fNrows,fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasNoTrans,CblasNoTrans,fNrows,fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else
      Error("Mult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultB(ap,na,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Mult(const TMatrixTSym<Element> &a,const TMatrixT<Element> &b)
{
// Matrix multiplication, with A symmetric and B general.
// Create a matrix C such that C = A * B.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNcols() != b.GetNrows() || a.GetColLwb() != b.GetRowLwb()) {
         Error("Mult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymm (CblasRowMajor,CblasLeft,CblasUpper,fNrows,fNcols,1.0,
                   ap,a.GetNcols(),bp,b.GetNcols(),0.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymm (CblasRowMajor,CblasLeft,CblasUpper,fNrows,fNcols,1.0,
                   ap,a.GetNcols(),bp,b.GetNcols(),0.0,cp,fNcols);
   else
      Error("Mult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultB(ap,na,ncolsa,bp,nb,ncolsb,cp);

#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Mult(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
{
// Matrix multiplication, with A general and B symmetric.
// Create a matrix C such that C = A * B.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNcols() != b.GetNrows() || a.GetColLwb() != b.GetRowLwb()) {
         Error("Mult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymm (CblasRowMajor,CblasRight,CblasUpper,fNrows,fNcols,1.0,
                   bp,b.GetNcols(),ap,a.GetNcols(),0.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymm (CblasRowMajor,CblasRight,CblasUpper,fNrows,fNcols,1.0,
                   bp,b.GetNcols(),ap,a.GetNcols(),0.0,cp,fNcols);
   else
      Error("Mult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultB(ap,na,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Mult(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b)
{
// Matrix multiplication, with A symmetric and B symmetric.
// (Actually copied for the moment routine for B general)
// Create a matrix C such that C = A * B.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNcols() != b.GetNrows() || a.GetColLwb() != b.GetRowLwb()) {
         Error("Mult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("Mult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymm (CblasRowMajor,CblasLeft,CblasUpper,fNrows,fNcols,1.0,
                   ap,a.GetNcols(),bp,b.GetNcols(),0.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymm (CblasRowMajor,CblasLeft,CblasUpper,fNrows,fNcols,1.0,
                   ap,a.GetNcols(),bp,b.GetNcols(),0.0,cp,fNcols);
   else
      Error("Mult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultB(ap,na,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::TMult(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
{
// Create a matrix C such that C = A' * B. In other words,
// c[i,j] = SUM{ a[k,i] * b[k,j] }.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNrows() != b.GetNrows() || a.GetRowLwb() != b.GetRowLwb()) {
         Error("TMult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("TMult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("TMult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasTrans,CblasNoTrans,this->fNrows,this->fNcols,a.GetNrows(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasTrans,CblasNoTrans,fNrows,fNcols,a.GetNrows(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else
      Error("TMult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AtMultB(ap,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::TMult(const TMatrixT<Element> &a,const TMatrixTSym<Element> &b)
{
// Create a matrix C such that C = A' * B. In other words,
// c[i,j] = SUM{ a[k,i] * b[k,j] }.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNrows() != b.GetNrows() || a.GetRowLwb() != b.GetRowLwb()) {
         Error("TMult","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("TMult","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("TMult","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasTrans,CblasNoTrans,fNrows,fNcols,a.GetNrows(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasTrans,CblasNoTrans,fNrows,fNcols,a.GetNrows(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else
      Error("TMult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AtMultB(ap,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::MultT(const TMatrixT<Element> &a,const TMatrixT<Element> &b)
{
// General matrix multiplication. Create a matrix C such that C = A * B^T.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());

      if (a.GetNcols() != b.GetNcols() || a.GetColLwb() != b.GetColLwb()) {
         Error("MultT","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("MultT","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("MultT","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasNoTrans,CblasTrans,fNrows,fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasNoTrans,CblasTrans,fNrows,fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else
      Error("MultT","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultBt(ap,na,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::MultT(const TMatrixTSym<Element> &a,const TMatrixT<Element> &b)
{
// Matrix multiplication, with A symmetric and B general.
// Create a matrix C such that C = A * B^T.

   if (gMatrixCheck) {
      R__ASSERT(a.IsValid());
      R__ASSERT(b.IsValid());
      if (a.GetNcols() != b.GetNcols() || a.GetColLwb() != b.GetColLwb()) {
         Error("MultT","A rows and B columns incompatible");
         return;
      }

      if (this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("MultT","this->GetMatrixArray() == a.GetMatrixArray()");
         return;
      }

      if (this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("MultT","this->GetMatrixArray() == b.GetMatrixArray()");
         return;
      }
   }

#ifdef CBLAS
   const Element *ap = a.GetMatrixArray();
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasNoTrans,CblasTrans,this->fNrows,this->fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasNoTrans,CblasTrans,fNrows,fNcols,a.GetNcols(),
                   1.0,ap,a.GetNcols(),bp,b.GetNcols(),1.0,cp,fNcols);
   else
      Error("MultT","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t na     = a.GetNoElements();
   const Int_t nb     = b.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = b.GetNcols();
   const Element * const ap = a.GetMatrixArray();
   const Element * const bp = b.GetMatrixArray();
         Element *       cp = this->GetMatrixArray();

   AMultBt(ap,na,ncolsa,bp,nb,ncolsb,cp);
#endif
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::Use(Int_t row_lwb,Int_t row_upb,
                                          Int_t col_lwb,Int_t col_upb,Element *data)
{
// Use the array data to fill the matrix ([row_lwb..row_upb] x [col_lwb..col_upb])

   if (gMatrixCheck) {
      if (row_upb < row_lwb)
      {
         Error("Use","row_upb=%d < row_lwb=%d",row_upb,row_lwb);
         return *this;
      }
      if (col_upb < col_lwb)
      {
         Error("Use","col_upb=%d < col_lwb=%d",col_upb,col_lwb);
         return *this;
      }
   }

   Clear();
   this->fNrows    = row_upb-row_lwb+1;
   this->fNcols    = col_upb-col_lwb+1;
   this->fRowLwb   = row_lwb;
   this->fColLwb   = col_lwb;
   this->fNelems   = this->fNrows*this->fNcols;
         fElements = data;
   this->fIsOwner  = kFALSE;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixT<Element>::GetSub(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                                 TMatrixTBase<Element> &target,Option_t *option) const
{
// Get submatrix [row_lwb..row_upb] x [col_lwb..col_upb]; The indexing range of the
// returned matrix depends on the argument option:
//
// option == "S" : return [0..row_upb-row_lwb+1][0..col_upb-col_lwb+1] (default)
// else          : return [row_lwb..row_upb][col_lwb..col_upb]

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      if (row_lwb < this->fRowLwb || row_lwb > this->fRowLwb+this->fNrows-1) {
         Error("GetSub","row_lwb out of bounds");
         return target;
      }
      if (col_lwb < this->fColLwb || col_lwb > this->fColLwb+this->fNcols-1) {
         Error("GetSub","col_lwb out of bounds");
         return target;
      }
      if (row_upb < this->fRowLwb || row_upb > this->fRowLwb+this->fNrows-1) {
         Error("GetSub","row_upb out of bounds");
         return target;
      }
      if (col_upb < this->fColLwb || col_upb > this->fColLwb+this->fNcols-1) {
         Error("GetSub","col_upb out of bounds");
         return target;
      }
      if (row_upb < row_lwb || col_upb < col_lwb) {
         Error("GetSub","row_upb < row_lwb || col_upb < col_lwb");
         return target;
      }
   }

   TString opt(option);
   opt.ToUpper();
   const Int_t shift = (opt.Contains("S")) ? 1 : 0;

   const Int_t row_lwb_sub = (shift) ? 0               : row_lwb;
   const Int_t row_upb_sub = (shift) ? row_upb-row_lwb : row_upb;
   const Int_t col_lwb_sub = (shift) ? 0               : col_lwb;
   const Int_t col_upb_sub = (shift) ? col_upb-col_lwb : col_upb;

   target.ResizeTo(row_lwb_sub,row_upb_sub,col_lwb_sub,col_upb_sub);
   const Int_t nrows_sub = row_upb_sub-row_lwb_sub+1;
   const Int_t ncols_sub = col_upb_sub-col_lwb_sub+1;

   if (target.GetRowIndexArray() && target.GetColIndexArray()) {
      for (Int_t irow = 0; irow < nrows_sub; irow++) {
         for (Int_t icol = 0; icol < ncols_sub; icol++) {
            target(irow+row_lwb_sub,icol+col_lwb_sub) = (*this)(row_lwb+irow,col_lwb+icol);
         }
      }
   } else {
      const Element *ap = this->GetMatrixArray()+(row_lwb-this->fRowLwb)*this->fNcols+(col_lwb-this->fColLwb);
            Element *bp = target.GetMatrixArray();

      for (Int_t irow = 0; irow < nrows_sub; irow++) {
         const Element *ap_sub = ap;
         for (Int_t icol = 0; icol < ncols_sub; icol++) {
            *bp++ = *ap_sub++;
         }
         ap += this->fNcols;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixT<Element>::SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source)
{
// Insert matrix source starting at [row_lwb][col_lwb], thereby overwriting the part
// [row_lwb..row_lwb+nrows_source][col_lwb..col_lwb+ncols_source];

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(source.IsValid());

      if (row_lwb < this->fRowLwb || row_lwb > this->fRowLwb+this->fNrows-1) {
         Error("SetSub","row_lwb outof bounds");
         return *this;
      }
      if (col_lwb < this->fColLwb || col_lwb > this->fColLwb+this->fNcols-1) {
         Error("SetSub","col_lwb outof bounds");
         return *this;
      }
      if (row_lwb+source.GetNrows() > this->fRowLwb+this->fNrows ||
            col_lwb+source.GetNcols() > this->fColLwb+this->fNcols) {
         Error("SetSub","source matrix too large");
         return *this;
      }
   }

   const Int_t nRows_source = source.GetNrows();
   const Int_t nCols_source = source.GetNcols();

   if (source.GetRowIndexArray() && source.GetColIndexArray()) {
      const Int_t rowlwb_s = source.GetRowLwb();
      const Int_t collwb_s = source.GetColLwb();
      for (Int_t irow = 0; irow < nRows_source; irow++) {
         for (Int_t icol = 0; icol < nCols_source; icol++) {
            (*this)(row_lwb+irow,col_lwb+icol) = source(rowlwb_s+irow,collwb_s+icol);
         }
      }
   } else {
      const Element *bp = source.GetMatrixArray();
            Element *ap = this->GetMatrixArray()+(row_lwb-this->fRowLwb)*this->fNcols+(col_lwb-this->fColLwb);

      for (Int_t irow = 0; irow < nRows_source; irow++) {
         Element *ap_sub = ap;
         for (Int_t icol = 0; icol < nCols_source; icol++) {
            *ap_sub++ = *bp++;
         }
         ap += this->fNcols;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixT<Element>::ResizeTo(Int_t nrows,Int_t ncols,Int_t /*nr_nonzeros*/)
{
// Set size of the matrix to nrows x ncols
// New dynamic elements are created, the overlapping part of the old ones are
// copied to the new structures, then the old elements are deleted.

   R__ASSERT(this->IsValid());
   if (!this->fIsOwner) {
      Error("ResizeTo(Int_t,Int_t)","Not owner of data array,cannot resize");
      return *this;
   }

   if (this->fNelems > 0) {
      if (this->fNrows == nrows && this->fNcols == ncols)
         return *this;
      else if (nrows == 0 || ncols == 0) {
         this->fNrows = nrows; this->fNcols = ncols;
         Clear();
         return *this;
      }

      Element    *elements_old = GetMatrixArray();
      const Int_t nelems_old   = this->fNelems;
      const Int_t nrows_old    = this->fNrows;
      const Int_t ncols_old    = this->fNcols;

      Allocate(nrows,ncols);
      R__ASSERT(this->IsValid());

      Element *elements_new = GetMatrixArray();
      // new memory should be initialized but be careful not to wipe out the stack
      // storage. Initialize all when old or new storage was on the heap
      if (this->fNelems > this->kSizeMax || nelems_old > this->kSizeMax)
         memset(elements_new,0,this->fNelems*sizeof(Element));
      else if (this->fNelems > nelems_old)
         memset(elements_new+nelems_old,0,(this->fNelems-nelems_old)*sizeof(Element));

      // Copy overlap
      const Int_t ncols_copy = TMath::Min(this->fNcols,ncols_old);
      const Int_t nrows_copy = TMath::Min(this->fNrows,nrows_old);

      const Int_t nelems_new = this->fNelems;
      if (ncols_old < this->fNcols) {
         for (Int_t i = nrows_copy-1; i >= 0; i--) {
            Memcpy_m(elements_new+i*this->fNcols,elements_old+i*ncols_old,ncols_copy,
                     nelems_new,nelems_old);
            if (this->fNelems <= this->kSizeMax && nelems_old <= this->kSizeMax)
               memset(elements_new+i*this->fNcols+ncols_copy,0,(this->fNcols-ncols_copy)*sizeof(Element));
         }
      } else {
         for (Int_t i = 0; i < nrows_copy; i++)
            Memcpy_m(elements_new+i*this->fNcols,elements_old+i*ncols_old,ncols_copy,
                     nelems_new,nelems_old);
      }

      Delete_m(nelems_old,elements_old);
   } else {
      Allocate(nrows,ncols,0,0,1);
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixT<Element>::ResizeTo(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                                   Int_t /*nr_nonzeros*/)
{
// Set size of the matrix to [row_lwb:row_upb] x [col_lwb:col_upb]
// New dynamic elemenst are created, the overlapping part of the old ones are
// copied to the new structures, then the old elements are deleted.

   R__ASSERT(this->IsValid());
   if (!this->fIsOwner) {
      Error("ResizeTo(Int_t,Int_t,Int_t,Int_t)","Not owner of data array,cannot resize");
      return *this;
   }

   const Int_t new_nrows = row_upb-row_lwb+1;
   const Int_t new_ncols = col_upb-col_lwb+1;

   if (this->fNelems > 0) {

      if (this->fNrows  == new_nrows  && this->fNcols  == new_ncols &&
           this->fRowLwb == row_lwb    && this->fColLwb == col_lwb)
          return *this;
      else if (new_nrows == 0 || new_ncols == 0) {
         this->fNrows = new_nrows; this->fNcols = new_ncols;
         this->fRowLwb = row_lwb; this->fColLwb = col_lwb;
         Clear();
         return *this;
      }

      Element    *elements_old = GetMatrixArray();
      const Int_t nelems_old   = this->fNelems;
      const Int_t nrows_old    = this->fNrows;
      const Int_t ncols_old    = this->fNcols;
      const Int_t rowLwb_old   = this->fRowLwb;
      const Int_t colLwb_old   = this->fColLwb;

      Allocate(new_nrows,new_ncols,row_lwb,col_lwb);
      R__ASSERT(this->IsValid());

      Element *elements_new = GetMatrixArray();
      // new memory should be initialized but be careful not to wipe out the stack
      // storage. Initialize all when old or new storage was on the heap
      if (this->fNelems > this->kSizeMax || nelems_old > this->kSizeMax)
         memset(elements_new,0,this->fNelems*sizeof(Element));
      else if (this->fNelems > nelems_old)
         memset(elements_new+nelems_old,0,(this->fNelems-nelems_old)*sizeof(Element));

      // Copy overlap
      const Int_t rowLwb_copy = TMath::Max(this->fRowLwb,rowLwb_old);
      const Int_t colLwb_copy = TMath::Max(this->fColLwb,colLwb_old);
      const Int_t rowUpb_copy = TMath::Min(this->fRowLwb+this->fNrows-1,rowLwb_old+nrows_old-1);
      const Int_t colUpb_copy = TMath::Min(this->fColLwb+this->fNcols-1,colLwb_old+ncols_old-1);

      const Int_t nrows_copy = rowUpb_copy-rowLwb_copy+1;
      const Int_t ncols_copy = colUpb_copy-colLwb_copy+1;

      if (nrows_copy > 0 && ncols_copy > 0) {
         const Int_t colOldOff = colLwb_copy-colLwb_old;
         const Int_t colNewOff = colLwb_copy-this->fColLwb;
         if (ncols_old < this->fNcols) {
            for (Int_t i = nrows_copy-1; i >= 0; i--) {
               const Int_t iRowOld = rowLwb_copy+i-rowLwb_old;
               const Int_t iRowNew = rowLwb_copy+i-this->fRowLwb;
               Memcpy_m(elements_new+iRowNew*this->fNcols+colNewOff,
                        elements_old+iRowOld*ncols_old+colOldOff,ncols_copy,this->fNelems,nelems_old);
               if (this->fNelems <= this->kSizeMax && nelems_old <= this->kSizeMax)
                  memset(elements_new+iRowNew*this->fNcols+colNewOff+ncols_copy,0,
                         (this->fNcols-ncols_copy)*sizeof(Element));
            }
         } else {
            for (Int_t i = 0; i < nrows_copy; i++) {
               const Int_t iRowOld = rowLwb_copy+i-rowLwb_old;
               const Int_t iRowNew = rowLwb_copy+i-this->fRowLwb;
               Memcpy_m(elements_new+iRowNew*this->fNcols+colNewOff,
                        elements_old+iRowOld*ncols_old+colOldOff,ncols_copy,this->fNelems,nelems_old);
            }
         }
      }

      Delete_m(nelems_old,elements_old);
   } else {
      Allocate(new_nrows,new_ncols,row_lwb,col_lwb,1);
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
Double_t TMatrixT<Element>::Determinant() const
{
// Return the matrix determinant 

   const TMatrixT<Element> &tmp = *this;
   TDecompLU lu(tmp,this->fTol);
   Double_t d1,d2;
   lu.Det(d1,d2);
   return d1*TMath::Power(2.0,d2);
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Determinant(Double_t &d1,Double_t &d2) const
{
// Return the matrix determinant as d1,d2 where det = d1*TMath::Power(2.0,d2)

   const TMatrixT<Element> &tmp = *this;
   TDecompLU lu(tmp,Double_t(this->fTol));
   lu.Det(d1,d2);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::Invert(Double_t *det)
{
// Invert the matrix and calculate its determinant

   R__ASSERT(this->IsValid());
   if (typeid(Element) == typeid(Double_t))
      TDecompLU::InvertLU(*dynamic_cast<TMatrixD *>(this),Double_t(this->fTol),det);
   else {
      TMatrixD tmp(*this);
      if (TDecompLU::InvertLU(tmp,Double_t(this->fTol),det)) {
         const Double_t *p1 = tmp.GetMatrixArray();
               Element  *p2 = this->GetMatrixArray();
         for (Int_t i = 0; i < this->GetNoElements(); i++)
            p2[i] = p1[i];
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::InvertFast(Double_t *det)
{
// Invert the matrix and calculate its determinant, however upto (6x6)
// a fast Cramer inversion is used .

   R__ASSERT(this->IsValid());

   const Char_t nRows = Char_t(this->GetNrows());
   switch (nRows) {
      case 1:
      {
         if (this->GetNrows() != this->GetNcols() || this->GetRowLwb() != this->GetColLwb()) {
             Error("Invert()","matrix should be square");
         } else {
            Element *pM = this->GetMatrixArray();
            if (*pM == 0.) {
               Error("InvertFast","matrix is singular");
               *det = 0;
            }
            else {
               *det = *pM;
               *pM = 1.0/(*pM);
            }
         }
         return *this;
      }
      case 2:
      {
         TMatrixTCramerInv::Inv2x2<Element>(*this,det);
         return *this;
      }
      case 3:
      {
         TMatrixTCramerInv::Inv3x3<Element>(*this,det);
         return *this;
      }
      case 4:
      {
         TMatrixTCramerInv::Inv4x4<Element>(*this,det);
         return *this;
      }
      case 5:
      {
         TMatrixTCramerInv::Inv5x5<Element>(*this,det);
         return *this;
      }
      case 6:
      {
         TMatrixTCramerInv::Inv6x6<Element>(*this,det);
         return *this;
      }

      default:
      {
         if(typeid(Element) == typeid(Double_t))
            TDecompLU::InvertLU(*dynamic_cast<TMatrixD *>(this),Double_t(this->fTol),det);
         else {
            TMatrixD tmp(*this);
            if (TDecompLU::InvertLU(tmp,Double_t(this->fTol),det)) {
               const Double_t *p1 = tmp.GetMatrixArray();
                     Element  *p2 = this->GetMatrixArray();
               for (Int_t i = 0; i < this->GetNoElements(); i++)
                  p2[i] = p1[i];
            }
         }
         return *this;
      }
    }
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::Transpose(const TMatrixT<Element> &source)
{
// Transpose matrix source.

   R__ASSERT(this->IsValid());
   R__ASSERT(source.IsValid());

   if (this->GetMatrixArray() == source.GetMatrixArray()) {
      Element *ap = this->GetMatrixArray();
      if (this->fNrows == this->fNcols && this->fRowLwb == this->fColLwb) {
         for (Int_t i = 0; i < this->fNrows; i++) {
            const Int_t off_i = i*this->fNrows;
            for (Int_t j = i+1; j < this->fNcols; j++) {
               const Int_t off_j = j*this->fNcols;
               const Element tmp = ap[off_i+j];
               ap[off_i+j] = ap[off_j+i];
               ap[off_j+i] = tmp;
            }
         }
      } else {
         Element *oldElems = new Element[source.GetNoElements()];
         memcpy(oldElems,source.GetMatrixArray(),source.GetNoElements()*sizeof(Element));
         const Int_t nrows_old  = this->fNrows;
         const Int_t ncols_old  = this->fNcols;
         const Int_t rowlwb_old = this->fRowLwb;
         const Int_t collwb_old = this->fColLwb;

         this->fNrows  = ncols_old;  this->fNcols  = nrows_old;
         this->fRowLwb = collwb_old; this->fColLwb = rowlwb_old;
         for (Int_t irow = this->fRowLwb; irow < this->fRowLwb+this->fNrows; irow++) {
            for (Int_t icol = this->fColLwb; icol < this->fColLwb+this->fNcols; icol++) {
               const Int_t off = (icol-collwb_old)*ncols_old;
               (*this)(irow,icol) = oldElems[off+irow-rowlwb_old];
            }
         }
         delete [] oldElems;
      }
   } else {
      if (this->fNrows  != source.GetNcols()  || this->fNcols  != source.GetNrows() ||
          this->fRowLwb != source.GetColLwb() || this->fColLwb != source.GetRowLwb())
      {
         Error("Transpose","matrix has wrong shape");
         return *this;
      }

      const Element *sp1 = source.GetMatrixArray();
      const Element *scp = sp1; // Row source pointer
            Element *tp  = this->GetMatrixArray();
      const Element * const tp_last = this->GetMatrixArray()+this->fNelems;

      // (This: target) matrix is traversed row-wise way,
      // whilst the source matrix is scanned column-wise
      while (tp < tp_last) {
         const Element *sp2 = scp++;

         // Move tp to the next elem in the row and sp to the next elem in the curr col
         while (sp2 < sp1+this->fNelems) {
            *tp++ = *sp2;
            sp2 += this->fNrows;
         }
      }
      R__ASSERT(tp == tp_last && scp == sp1+this->fNrows);
   }

   return *this;
}

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

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(v.IsValid());
      if (v.GetNoElements() < TMath::Max(this->fNrows,this->fNcols)) {
         Error("Rank1Update","vector too short");
         return *this;
      }
   }

   const Element * const pv = v.GetMatrixArray();
         Element *mp = this->GetMatrixArray();

   for (Int_t i = 0; i < this->fNrows; i++) {
      const Element tmp = alpha*pv[i];
      for (Int_t j = 0; j < this->fNcols; j++)
         *mp++ += tmp*pv[j];
   }

   return *this;
}

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

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(v1.IsValid());
      R__ASSERT(v2.IsValid());
      if (v1.GetNoElements() < this->fNrows) {
         Error("Rank1Update","vector v1 too short");
         return *this;
      }

      if (v2.GetNoElements() < this->fNcols) {
         Error("Rank1Update","vector v2 too short");
         return *this;
      }
   }

   const Element * const pv1 = v1.GetMatrixArray();
   const Element * const pv2 = v2.GetMatrixArray();
         Element *mp = this->GetMatrixArray();

   for (Int_t i = 0; i < this->fNrows; i++) {
      const Element tmp = alpha*pv1[i];
      for (Int_t j = 0; j < this->fNcols; j++)
         *mp++ += tmp*pv2[j];
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixT<Element>::Similarity(const TVectorT<Element> &v) const
{
// Calculate scalar v * (*this) * v^T

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(v.IsValid());
      if (this->fNcols != this->fNrows || this->fColLwb != this->fRowLwb) {
         Error("Similarity(const TVectorT &)","matrix is not square");
         return -1.;
      }

      if (this->fNcols != v.GetNrows() || this->fColLwb != v.GetLwb()) {
         Error("Similarity(const TVectorT &)","vector and matrix incompatible");
         return -1.;
      }
   }

   const Element *mp = this->GetMatrixArray(); // Matrix row ptr
   const Element *vp = v.GetMatrixArray();     // vector ptr

   Element sum1 = 0;
   const Element * const vp_first = vp;
   const Element * const vp_last  = vp+v.GetNrows();
   while (vp < vp_last) {
      Element sum2 = 0;
      for (const Element *sp = vp_first; sp < vp_last; )
         sum2 += *mp++ * *sp++;
      sum1 += sum2 * *vp++;
   }

   R__ASSERT(mp == this->GetMatrixArray()+this->GetNoElements());

   return sum1;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::NormByColumn(const TVectorT<Element> &v,Option_t *option)
{
// Multiply/divide matrix columns by a vector:
// option:
// "D"   :  b(i,j) = a(i,j)/v(i)   i = 0,fNrows-1 (default)
// else  :  b(i,j) = a(i,j)*v(i)

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(v.IsValid());
      if (v.GetNoElements() < this->fNrows) {
         Error("NormByColumn","vector shorter than matrix column");
         return *this;
      }
   }

   TString opt(option);
   opt.ToUpper();
   const Int_t divide = (opt.Contains("D")) ? 1 : 0;

   const Element *pv = v.GetMatrixArray();
         Element *mp = this->GetMatrixArray();
   const Element * const mp_last = mp+this->fNelems;

   if (divide) {
      for ( ; mp < mp_last; pv++) {
         for (Int_t j = 0; j < this->fNcols; j++)
         {
            if (*pv != 0.0)
               *mp++ /= *pv;
            else {
               Error("NormbyColumn","vector element %ld is zero",Long_t(pv-v.GetMatrixArray()));
               mp++;
            }
         }
      }
   } else {
      for ( ; mp < mp_last; pv++)
         for (Int_t j = 0; j < this->fNcols; j++)
            *mp++ *= *pv;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::NormByRow(const TVectorT<Element> &v,Option_t *option)
{
// Multiply/divide matrix rows with a vector:
// option:
// "D"   :  b(i,j) = a(i,j)/v(j)   i = 0,fNcols-1 (default)
// else  :  b(i,j) = a(i,j)*v(j)

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(v.IsValid());
      if (v.GetNoElements() < this->fNcols) {
         Error("NormByRow","vector shorter than matrix column");
         return *this;
      }
   }

   TString opt(option);
   opt.ToUpper();
   const Int_t divide = (opt.Contains("D")) ? 1 : 0;

   const Element *pv0 = v.GetMatrixArray();
   const Element *pv  = pv0;
         Element *mp  = this->GetMatrixArray();
   const Element * const mp_last = mp+this->fNelems;

   if (divide) {
      for ( ; mp < mp_last; pv = pv0 )
         for (Int_t j = 0; j < this->fNcols; j++) {
            if (*pv != 0.0)
               *mp++ /= *pv++;
            else {
               Error("NormbyRow","vector element %ld is zero",Long_t(pv-pv0));
               mp++;
            }
         }
    } else {
       for ( ; mp < mp_last; pv = pv0 )
          for (Int_t j = 0; j < this->fNcols; j++)
             *mp++ *= *pv++;
    }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator=(const TMatrixT<Element> &source)
{
// Assignment operator

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=(const TMatrixT &)","matrices not compatible");
      return *this;
   }

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);
      memcpy(fElements,source.GetMatrixArray(),this->fNelems*sizeof(Element));
      this->fTol = source.GetTol();
   }
   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator=(const TMatrixTSym<Element> &source)
{
// Assignment operator

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=(const TMatrixTSym &)","matrices not compatible");
      return *this;
   }

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);
      memcpy(fElements,source.GetMatrixArray(),this->fNelems*sizeof(Element));
      this->fTol = source.GetTol();
   }
   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator=(const TMatrixTSparse<Element> &source)
{
// Assignment operator

   if ((gMatrixCheck &&
        this->GetNrows()  != source.GetNrows())  || this->GetNcols()  != source.GetNcols() ||
        this->GetRowLwb() != source.GetRowLwb() || this->GetColLwb() != source.GetColLwb()) {
      Error("operator=(const TMatrixTSparse &","matrices not compatible");
      return *this;
   }

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);
      memset(fElements,0,this->fNelems*sizeof(Element));

      const Element * const sp = source.GetMatrixArray();
            Element *       tp = this->GetMatrixArray();

      const Int_t * const pRowIndex = source.GetRowIndexArray();
      const Int_t * const pColIndex = source.GetColIndexArray();

      for (Int_t irow = 0; irow < this->fNrows; irow++ ) {
         const Int_t off = irow*this->fNcols;
         const Int_t sIndex = pRowIndex[irow];
         const Int_t eIndex = pRowIndex[irow+1];
         for (Int_t index = sIndex; index < eIndex; index++)
            tp[off+pColIndex[index]] = sp[index];
      }
      this->fTol = source.GetTol();
   }
   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator=(const TMatrixTLazy<Element> &lazy_constructor)
{
// Assignment operator

   R__ASSERT(this->IsValid());

   if (lazy_constructor.GetRowUpb() != this->GetRowUpb() ||
       lazy_constructor.GetColUpb() != this->GetColUpb() ||
       lazy_constructor.GetRowLwb() != this->GetRowLwb() ||
       lazy_constructor.GetColLwb() != this->GetColLwb()) {
      Error("operator=(const TMatrixTLazy&)", "matrix is incompatible with "
            "the assigned Lazy matrix");
      return *this;
   }

   lazy_constructor.FillIn(*this);
   return *this;
}

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

   R__ASSERT(this->IsValid());

   Element *ep = this->GetMatrixArray();
   const Element * const ep_last = ep+this->fNelems;
   while (ep < ep_last)
      *ep++ = val;

   return *this;
}

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

   R__ASSERT(this->IsValid());

   Element *ep = this->GetMatrixArray();
   const Element * const ep_last = ep+this->fNelems;
   while (ep < ep_last)
      *ep++ += val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator-=(Element val)
{
// Subtract val from every element of the matrix.

   R__ASSERT(this->IsValid());

   Element *ep = this->GetMatrixArray();
   const Element * const ep_last = ep+this->fNelems;
   while (ep < ep_last)
      *ep++ -= val;

   return *this;
}

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

   R__ASSERT(this->IsValid());

   Element *ep = this->GetMatrixArray();
   const Element * const ep_last = ep+this->fNelems;
   while (ep < ep_last)
      *ep++ *= val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator+=(const TMatrixT<Element> &source)
{
// Add the source matrix.

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator+=(const TMatrixT &)","matrices not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
   Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+this->fNelems;
   while (tp < tp_last)
      *tp++ += *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator+=(const TMatrixTSym<Element> &source)
{
// Add the source matrix.

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator+=(const TMatrixTSym &)","matrices not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
   Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+this->fNelems;
   while (tp < tp_last)
      *tp++ += *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator-=(const TMatrixT<Element> &source)
{
// Subtract the source matrix.

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=-(const TMatrixT &)","matrices not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
   Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+this->fNelems;
   while (tp < tp_last)
      *tp++ -= *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator-=(const TMatrixTSym<Element> &source)
{
// Subtract the source matrix.

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=-(const TMatrixTSym &)","matrices not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
   Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+this->fNelems;
   while (tp < tp_last)
      *tp++ -= *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator*=(const TMatrixT<Element> &source)
{
// Compute target = target * source inplace. Strictly speaking, it can't be
// done inplace, though only the row of the target matrix needs to be saved.
// "Inplace" multiplication is only allowed when the 'source' matrix is square.

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(source.IsValid());
      if (this->fNcols != source.GetNrows() || this->fColLwb != source.GetRowLwb() ||
          this->fNcols != source.GetNcols() || this->fColLwb != source.GetColLwb()) {
         Error("operator*=(const TMatrixT &)","source matrix has wrong shape");
         return *this;
      }
   }

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

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

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

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

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator*=(const TMatrixTSym<Element> &source)
{
// Compute target = target * source inplace. Strictly speaking, it can't be
// done inplace, though only the row of the target matrix needs to be saved.

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(source.IsValid());
      if (this->fNcols != source.GetNrows() || this->fColLwb != source.GetRowLwb()) {
         Error("operator*=(const TMatrixTSym &)","source matrix has wrong shape");
         return *this;
      }
   }

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

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

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

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

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator*=(const TMatrixTDiag_const<Element> &diag)
{
// Multiply a matrix row by the diagonal of another matrix
// matrix(i,j) *= diag(j), j=0,fNcols-1

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(diag.GetMatrix()->IsValid());
      if (this->fNcols != diag.GetNdiags()) {
         Error("operator*=(const TMatrixTDiag_const &)","wrong diagonal length");
         return *this;
      }
   }

   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Int_t inc = diag.GetInc();
   while (mp < mp_last) {
      const Element *dp = diag.GetPtr();
      for (Int_t j = 0; j < this->fNcols; j++) {
         *mp++ *= *dp;
         dp += inc;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator/=(const TMatrixTDiag_const<Element> &diag)
{
// Divide a matrix row by the diagonal of another matrix
// matrix(i,j) /= diag(j)

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(diag.GetMatrix()->IsValid());
      if (this->fNcols != diag.GetNdiags()) {
         Error("operator/=(const TMatrixTDiag_const &)","wrong diagonal length");
         return *this;
      }
   }

   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Int_t inc = diag.GetInc();
   while (mp < mp_last) {
      const Element *dp = diag.GetPtr();
      for (Int_t j = 0; j < this->fNcols; j++) {
         if (*dp != 0.0)
            *mp++ /= *dp;
         else {
            Error("operator/=","%d-diagonal element is zero",j);
            mp++;
         }
         dp += inc;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator*=(const TMatrixTColumn_const<Element> &col)
{
// Multiply a matrix by the column of another matrix
// matrix(i,j) *= another(i,k) for fixed k

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

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(mt->IsValid());
      if (this->fNrows != mt->GetNrows()) {
         Error("operator*=(const TMatrixTColumn_const &)","wrong column length");
         return *this;
      }
   }

   const Element * const endp = col.GetPtr()+mt->GetNoElements();
   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Element *cp = col.GetPtr();      //  ptr
   const Int_t inc = col.GetInc();
   while (mp < mp_last) {
      R__ASSERT(cp < endp);
      for (Int_t j = 0; j < this->fNcols; j++)
         *mp++ *= *cp;
      cp += inc;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator/=(const TMatrixTColumn_const<Element> &col)
{
// Divide a matrix by the column of another matrix
// matrix(i,j) /= another(i,k) for fixed k

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

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(mt->IsValid());
      if (this->fNrows != mt->GetNrows()) {
         Error("operator/=(const TMatrixTColumn_const &)","wrong column matrix");
         return *this;
      }
   }

   const Element * const endp = col.GetPtr()+mt->GetNoElements();
   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Element *cp = col.GetPtr();      //  ptr
   const Int_t inc = col.GetInc();
   while (mp < mp_last) {
      R__ASSERT(cp < endp);
      if (*cp != 0.0) {
         for (Int_t j = 0; j < this->fNcols; j++)
            *mp++ /= *cp;
      } else {
         const Int_t icol = (cp-mt->GetMatrixArray())/inc;
         Error("operator/=","%d-row of matrix column is zero",icol);
         mp += this->fNcols;
      }
      cp += inc;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator*=(const TMatrixTRow_const<Element> &row)
{
// Multiply a matrix by the row of another matrix
// matrix(i,j) *= another(k,j) for fixed k

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

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(mt->IsValid());
      if (this->fNcols != mt->GetNcols()) {
         Error("operator*=(const TMatrixTRow_const &)","wrong row length");
         return *this;
      }
   }

   const Element * const endp = row.GetPtr()+mt->GetNoElements();
   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Int_t inc = row.GetInc();
   while (mp < mp_last) {
      const Element *rp = row.GetPtr();    // Row ptr
      for (Int_t j = 0; j < this->fNcols; j++) {
         R__ASSERT(rp < endp);
         *mp++ *= *rp;
         rp += inc;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &TMatrixT<Element>::operator/=(const TMatrixTRow_const<Element> &row)
{
// Divide a matrix by the row of another matrix
// matrix(i,j) /= another(k,j) for fixed k

   const TMatrixTBase<Element> *mt = row.GetMatrix();
   R__ASSERT(this->IsValid());
   R__ASSERT(mt->IsValid());
 
   if (this->fNcols != mt->GetNcols()) {
      Error("operator/=(const TMatrixTRow_const &)","wrong row length");
      return *this;
   }

   const Element * const endp = row.GetPtr()+mt->GetNoElements();
   Element *mp = this->GetMatrixArray();  // Matrix ptr
   const Element * const mp_last = mp+this->fNelems;
   const Int_t inc = row.GetInc();
   while (mp < mp_last) {
      const Element *rp = row.GetPtr();    // Row ptr
      for (Int_t j = 0; j < this->fNcols; j++) {
         R__ASSERT(rp < endp);
         if (*rp != 0.0) {
           *mp++ /= *rp;
         } else {
            Error("operator/=","%d-col of matrix row is zero",j);
            mp++;
         }
         rp += inc;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
const TMatrixT<Element> TMatrixT<Element>::EigenVectors(TVectorT<Element> &eigenValues) const
{
// Return a matrix containing the eigen-vectors ordered by descending values
// of Re^2+Im^2 of the complex eigen-values .
// If the matrix is asymmetric, only the real part of the eigen-values is
// returned . For full functionality use TMatrixDEigen .

   if (!this->IsSymmetric())
      Warning("EigenVectors(TVectorT &)","Only real part of eigen-values will be returned");
   TMatrixDEigen eigen(*this);
   eigenValues.ResizeTo(this->fNrows);
   eigenValues = eigen.GetEigenValuesRe();
   return eigen.GetEigenVectors();
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator+(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1+source2

   TMatrixT<Element> target(source1);
   target += source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator+(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// operation this = source1+source2

   TMatrixT<Element> target(source1);
   target += source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator+(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1+source2

   return operator+(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator+(const TMatrixT<Element> &source,Element val)
{
// operation this = source+val

   TMatrixT<Element> target(source);
   target += val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator+(Element val,const TMatrixT<Element> &source)
{
// operation this = val+source

   return operator+(source,val);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator-(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1-source2

   TMatrixT<Element> target(source1);
   target -= source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator-(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// operation this = source1-source2

   TMatrixT<Element> target(source1);
   target -= source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator-(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1-source2

   return Element(-1.0)*(operator-(source2,source1));
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator-(const TMatrixT<Element> &source,Element val)
{
// operation this = source-val

   TMatrixT<Element> target(source);
   target -= val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator-(Element val,const TMatrixT<Element> &source)
{
// operation this = val-source

   return Element(-1.0)*operator-(source,val);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(Element val,const TMatrixT<Element> &source)
{
// operation this = val*source

   TMatrixT<Element> target(source);
   target *= val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(const TMatrixT<Element> &source,Element val)
{
// operation this = val*source

   return operator*(val,source);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1*source2

   TMatrixT<Element> target(source1,TMatrixT<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// operation this = source1*source2

   TMatrixT<Element> target(source1,TMatrixT<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// operation this = source1*source2

   TMatrixT<Element> target(source1,TMatrixT<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator*(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
// operation this = source1*source2

   TMatrixT<Element> target(source1,TMatrixT<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator&&(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// Logical AND

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator&&(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last)
      *tp++ = (*sp1++ != 0.0 && *sp2++ != 0.0);

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator&&(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// Logical AND

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator&&(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last)
      *tp++ = (*sp1++ != 0.0 && *sp2++ != 0.0);

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator&&(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// Logical AND
   return operator&&(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator||(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// Logical OR

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator||(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last)
      *tp++ = (*sp1++ != 0.0 || *sp2++ != 0.0);

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator||(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// Logical OR

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator||(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last)
      *tp++ = (*sp1++ != 0.0 || *sp2++ != 0.0);

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator||(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// Logical OR

   return operator||(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 > source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator|(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) > (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// logical operation source1 > source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator>(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) > (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 > source2

   return operator<=(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>=(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 >= source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator>=(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) >= (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>=(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// logical operation source1 >= source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator>=(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) >= (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator>=(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 >= source2

   return operator<(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<=(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 <= source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<=(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) <= (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<=(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// logical operation source1 <= source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<=(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) <= (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<=(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 <= source2

   return operator>(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 < source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) < (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// logical operation source1 < source2

  TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp < tp_last) {
      *tp++ = (*sp1) < (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator<(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 < source2

   return operator>=(source2,source1);
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator!=(const TMatrixT<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 != source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator!=(const TMatrixT&,const TMatrixT&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp != tp_last) {
      *tp++ = (*sp1) != (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator!=(const TMatrixT<Element> &source1,const TMatrixTSym<Element> &source2)
{
// logical operation source1 != source2

   TMatrixT<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator!=(const TMatrixT&,const TMatrixTSym&)","matrices not compatible");
      return target;
   }

   target.ResizeTo(source1);

   const Element *sp1 = source1.GetMatrixArray();
   const Element *sp2 = source2.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp != tp_last) {
      *tp++ = (*sp1) != (*sp2); sp1++; sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator!=(const TMatrixTSym<Element> &source1,const TMatrixT<Element> &source2)
{
// logical operation source1 != source2

   return operator!=(source2,source1);
}

/*
//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator!=(const TMatrixT<Element> &source1,Element val)
{
// logical operation source1 != val

   TMatrixT<Element> target; target.ResizeTo(source1);

   const Element *sp = source1.GetMatrixArray();
         Element *tp = target.GetMatrixArray();
   const Element * const tp_last = tp+target.GetNoElements();
   while (tp != tp_last) {
      *tp++ = (*sp != val); sp++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> operator!=(Element val,const TMatrixT<Element> &source1)
{
// logical operation source1 != val

   return operator!=(source1,val);
}
*/

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &Add(TMatrixT<Element> &target,Element scalar,const TMatrixT<Element> &source)
{
// Modify addition: target += scalar * source.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("Add(TMatrixT &,Element,const TMatrixT &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   if (scalar == 0) {
       while ( tp < ftp )
          *tp++  = scalar * (*sp++);
   } else if (scalar == 1.) {
       while ( tp < ftp )
          *tp++ = (*sp++);
   } else {
       while ( tp < ftp )
          *tp++ += scalar * (*sp++);
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &Add(TMatrixT<Element> &target,Element scalar,const TMatrixTSym<Element> &source)
{
// Modify addition: target += scalar * source.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("Add(TMatrixT &,Element,const TMatrixTSym &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp )
      *tp++ += scalar * (*sp++);

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixT<Element> &source)
{
// Multiply target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("ElementMult(TMatrixT &,const TMatrixT &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp )
      *tp++ *= *sp++;

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixTSym<Element> &source)
{
// Multiply target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("ElementMult(TMatrixT &,const TMatrixTSym &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp )
      *tp++ *= *sp++;

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &ElementDiv(TMatrixT<Element> &target,const TMatrixT<Element> &source)
{
// Divide target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("ElementDiv(TMatrixT &,const TMatrixT &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp ) {
      if (*sp != 0.0)
         *tp++ /= *sp++;
      else {
         const Int_t irow = (sp-source.GetMatrixArray())/source.GetNcols();
         const Int_t icol = (sp-source.GetMatrixArray())%source.GetNcols();
         Error("ElementDiv","source (%d,%d) is zero",irow,icol);
         tp++;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixT<Element> &ElementDiv(TMatrixT<Element> &target,const TMatrixTSym<Element> &source)
{
// Multiply target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      ::Error("ElementDiv(TMatrixT &,const TMatrixTSym &)","matrices not compatible");
      return target;
   }

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp ) {
      if (*sp != 0.0)
         *tp++ /= *sp++;
      else {
         const Int_t irow = (sp-source.GetMatrixArray())/source.GetNcols();
         const Int_t icol = (sp-source.GetMatrixArray())%source.GetNcols();
         Error("ElementDiv","source (%d,%d) is zero",irow,icol);
         *tp++ = 0.0;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
void AMultB(const Element * const ap,Int_t na,Int_t ncolsa,
            const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp)
{
// Elementary routine to calculate matrix multiplication A*B

   const Element *arp0 = ap;                     // Pointer to  A[i,0];
   while (arp0 < ap+na) {
      for (const Element *bcp = bp; bcp < bp+ncolsb; ) { // Pointer to the j-th column of B, Start bcp = B[0,0]
         const Element *arp = arp0;                       // Pointer to the i-th row of A, reset to A[i,0]
         Element cij = 0;
         while (bcp < bp+nb) {                     // Scan the i-th row of A and
            cij += *arp++ * *bcp;                   // the j-th col of B
            bcp += ncolsb;
         }
         *cp++ = cij;
         bcp -= nb-1;                              // Set bcp to the (j+1)-th col
      }
      arp0 += ncolsa;                             // Set ap to the (i+1)-th row
   }
}

//______________________________________________________________________________
template<class Element>
void AtMultB(const Element * const ap,Int_t ncolsa,
             const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp)
{
// Elementary routine to calculate matrix multiplication A^T*B

   const Element *acp0 = ap;           // Pointer to  A[i,0];
   while (acp0 < ap+ncolsa) {
      for (const Element *bcp = bp; bcp < bp+ncolsb; ) { // Pointer to the j-th column of B, Start bcp = B[0,0]
         const Element *acp = acp0;                       // Pointer to the i-th column of A, reset to A[0,i]
         Element cij = 0;
         while (bcp < bp+nb) {           // Scan the i-th column of A and
            cij += *acp * *bcp;           // the j-th col of B
            acp += ncolsa;
            bcp += ncolsb;
         }
         *cp++ = cij;
         bcp -= nb-1;                    // Set bcp to the (j+1)-th col
      }
      acp0++;                           // Set acp0 to the (i+1)-th col
   }
}

//______________________________________________________________________________
template<class Element>
void AMultBt(const Element * const ap,Int_t na,Int_t ncolsa,
             const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp)
{
// Elementary routine to calculate matrix multiplication A*B^T

   const Element *arp0 = ap;                    // Pointer to  A[i,0];
   while (arp0 < ap+na) {
      const Element *brp0 = bp;                  // Pointer to  B[j,0];
      while (brp0 < bp+nb) {
         const Element *arp = arp0;               // Pointer to the i-th row of A, reset to A[i,0]
         const Element *brp = brp0;               // Pointer to the j-th row of B, reset to B[j,0]
         Element cij = 0;
         while (brp < brp0+ncolsb)                 // Scan the i-th row of A and
            cij += *arp++ * *brp++;                 // the j-th row of B
         *cp++ = cij;
         brp0 += ncolsb;                           // Set brp0 to the (j+1)-th row
      }
      arp0 += ncolsa;                             // Set arp0 to the (i+1)-th row
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixT<Element>::Streamer(TBuffer &R__b)
{
// Stream an object of class TMatrixT.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         Clear();
         R__b.ReadClassBuffer(TMatrixT<Element>::Class(),this,R__v,R__s,R__c);
      } else if (R__v == 2) { //process old version 2
         Clear();
         TObject::Streamer(R__b);
         this->MakeValid();
         R__b >> this->fNrows;
         R__b >> this->fNcols;
         R__b >> this->fNelems;
         R__b >> this->fRowLwb;
         R__b >> this->fColLwb;
         Char_t isArray;
         R__b >> isArray;
         if (isArray) {
            if (this->fNelems > 0) {
               fElements = new Element[this->fNelems];
               R__b.ReadFastArray(fElements,this->fNelems);
            } else
               fElements = 0;
         }
         R__b.CheckByteCount(R__s,R__c,TMatrixT<Element>::IsA());
      } else { //====process old versions before automatic schema evolution
         TObject::Streamer(R__b);
         this->MakeValid();
         R__b >> this->fNrows;
         R__b >> this->fNcols;
         R__b >> this->fRowLwb;
         R__b >> this->fColLwb;
         this->fNelems = R__b.ReadArray(fElements);
         R__b.CheckByteCount(R__s,R__c,TMatrixT<Element>::IsA());
      }
      // in version <=2 , the matrix was stored column-wise
      if (R__v <= 2 && fElements) {
         for (Int_t i = 0; i < this->fNrows; i++) {
            const Int_t off_i = i*this->fNcols;
            for (Int_t j = i; j < this->fNcols; j++) {
               const Int_t off_j = j*this->fNrows;
               const Element tmp = fElements[off_i+j];
               fElements[off_i+j] = fElements[off_j+i];
               fElements[off_j+i] = tmp;
            }
         }
      }
      if (this->fNelems > 0 && this->fNelems <= this->kSizeMax) {
         if (fElements) {
            memcpy(fDataStack,fElements,this->fNelems*sizeof(Element));
            delete [] fElements;
         }
         fElements = fDataStack;
      } else if (this->fNelems < 0)
         this->Invalidate();
      } else {
         R__b.WriteClassBuffer(TMatrixT<Element>::Class(),this);
   }
}

template class TMatrixT<Float_t>;

#ifndef ROOT_TMatrixFfwd
#include "TMatrixFfwd.h"
#endif
#ifndef ROOT_TMatrixFSymfwd
#include "TMatrixFSymfwd.h"
#endif

template TMatrixF  operator+  <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator+  <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator+  <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator+  <Float_t>(const TMatrixF    &source ,      Float_t      val    );
template TMatrixF  operator+  <Float_t>(      Float_t      val    ,const TMatrixF    &source );
template TMatrixF  operator-  <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator-  <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator-  <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator-  <Float_t>(const TMatrixF    &source ,      Float_t      val    );
template TMatrixF  operator-  <Float_t>(      Float_t      val    ,const TMatrixF    &source );
template TMatrixF  operator*  <Float_t>(      Float_t      val    ,const TMatrixF    &source );
template TMatrixF  operator*  <Float_t>(const TMatrixF    &source ,      Float_t      val    );
template TMatrixF  operator*  <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator*  <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator*  <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator*  <Float_t>(const TMatrixFSym &source1,const TMatrixFSym &source2);
template TMatrixF  operator&& <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator&& <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator&& <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator|| <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator|| <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator|| <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator>  <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator>  <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator>  <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator>= <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator>= <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator>= <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator<= <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator<= <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator<= <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator<  <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator<  <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator<  <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);
template TMatrixF  operator!= <Float_t>(const TMatrixF    &source1,const TMatrixF    &source2);
template TMatrixF  operator!= <Float_t>(const TMatrixF    &source1,const TMatrixFSym &source2);
template TMatrixF  operator!= <Float_t>(const TMatrixFSym &source1,const TMatrixF    &source2);

template TMatrixF &Add        <Float_t>(TMatrixF &target,      Float_t      scalar,const TMatrixF    &source);
template TMatrixF &Add        <Float_t>(TMatrixF &target,      Float_t      scalar,const TMatrixFSym &source);
template TMatrixF &ElementMult<Float_t>(TMatrixF &target,const TMatrixF    &source);
template TMatrixF &ElementMult<Float_t>(TMatrixF &target,const TMatrixFSym &source);
template TMatrixF &ElementDiv <Float_t>(TMatrixF &target,const TMatrixF    &source);
template TMatrixF &ElementDiv <Float_t>(TMatrixF &target,const TMatrixFSym &source);

template void AMultB <Float_t>(const Float_t * const ap,Int_t na,Int_t ncolsa,
                               const Float_t * const bp,Int_t nb,Int_t ncolsb,Float_t *cp);
template void AtMultB<Float_t>(const Float_t * const ap,Int_t ncolsa,
                               const Float_t * const bp,Int_t nb,Int_t ncolsb,Float_t *cp);
template void AMultBt<Float_t>(const Float_t * const ap,Int_t na,Int_t ncolsa,
                               const Float_t * const bp,Int_t nb,Int_t ncolsb,Float_t *cp);

#ifndef ROOT_TMatrixDfwd
#include "TMatrixDfwd.h"
#endif
#ifndef ROOT_TMatrixDSymfwd
#include "TMatrixDSymfwd.h"
#endif

template class TMatrixT<Double_t>;

template TMatrixD  operator+  <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator+  <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator+  <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator+  <Double_t>(const TMatrixD    &source ,      Double_t     val    );
template TMatrixD  operator+  <Double_t>(      Double_t     val    ,const TMatrixD    &source );
template TMatrixD  operator-  <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator-  <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator-  <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator-  <Double_t>(const TMatrixD    &source ,      Double_t     val    );
template TMatrixD  operator-  <Double_t>(      Double_t     val    ,const TMatrixD    &source );
template TMatrixD  operator*  <Double_t>(      Double_t     val    ,const TMatrixD    &source );
template TMatrixD  operator*  <Double_t>(const TMatrixD    &source ,      Double_t     val    );
template TMatrixD  operator*  <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator*  <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator*  <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator*  <Double_t>(const TMatrixDSym &source1,const TMatrixDSym &source2);
template TMatrixD  operator&& <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator&& <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator&& <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator|| <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator|| <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator|| <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator>  <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator>  <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator>  <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator>= <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator>= <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator>= <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator<= <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator<= <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator<= <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator<  <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator<  <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator<  <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);
template TMatrixD  operator!= <Double_t>(const TMatrixD    &source1,const TMatrixD    &source2);
template TMatrixD  operator!= <Double_t>(const TMatrixD    &source1,const TMatrixDSym &source2);
template TMatrixD  operator!= <Double_t>(const TMatrixDSym &source1,const TMatrixD    &source2);

template TMatrixD &Add        <Double_t>(TMatrixD &target,      Double_t     scalar,const TMatrixD    &source);
template TMatrixD &Add        <Double_t>(TMatrixD &target,      Double_t     scalar,const TMatrixDSym &source);
template TMatrixD &ElementMult<Double_t>(TMatrixD &target,const TMatrixD    &source);
template TMatrixD &ElementMult<Double_t>(TMatrixD &target,const TMatrixDSym &source);
template TMatrixD &ElementDiv <Double_t>(TMatrixD &target,const TMatrixD    &source);
template TMatrixD &ElementDiv <Double_t>(TMatrixD &target,const TMatrixDSym &source);

template void AMultB <Double_t>(const Double_t * const ap,Int_t na,Int_t ncolsa,
                                const Double_t * const bp,Int_t nb,Int_t ncolsb,Double_t *cp);
template void AtMultB<Double_t>(const Double_t * const ap,Int_t ncolsa,
                                const Double_t * const bp,Int_t nb,Int_t ncolsb,Double_t *cp);
template void AMultBt<Double_t>(const Double_t * const ap,Int_t na,Int_t ncolsa,
                                const Double_t * const bp,Int_t nb,Int_t ncolsb,Double_t *cp);
 TMatrixT.cxx:1
 TMatrixT.cxx:2
 TMatrixT.cxx:3
 TMatrixT.cxx:4
 TMatrixT.cxx:5
 TMatrixT.cxx:6
 TMatrixT.cxx:7
 TMatrixT.cxx:8
 TMatrixT.cxx:9
 TMatrixT.cxx:10
 TMatrixT.cxx:11
 TMatrixT.cxx:12
 TMatrixT.cxx:13
 TMatrixT.cxx:14
 TMatrixT.cxx:15
 TMatrixT.cxx:16
 TMatrixT.cxx:17
 TMatrixT.cxx:18
 TMatrixT.cxx:19
 TMatrixT.cxx:20
 TMatrixT.cxx:21
 TMatrixT.cxx:22
 TMatrixT.cxx:23
 TMatrixT.cxx:24
 TMatrixT.cxx:25
 TMatrixT.cxx:26
 TMatrixT.cxx:27
 TMatrixT.cxx:28
 TMatrixT.cxx:29
 TMatrixT.cxx:30
 TMatrixT.cxx:31
 TMatrixT.cxx:32
 TMatrixT.cxx:33
 TMatrixT.cxx:34
 TMatrixT.cxx:35
 TMatrixT.cxx:36
 TMatrixT.cxx:37
 TMatrixT.cxx:38
 TMatrixT.cxx:39
 TMatrixT.cxx:40
 TMatrixT.cxx:41
 TMatrixT.cxx:42
 TMatrixT.cxx:43
 TMatrixT.cxx:44
 TMatrixT.cxx:45
 TMatrixT.cxx:46
 TMatrixT.cxx:47
 TMatrixT.cxx:48
 TMatrixT.cxx:49
 TMatrixT.cxx:50
 TMatrixT.cxx:51
 TMatrixT.cxx:52
 TMatrixT.cxx:53
 TMatrixT.cxx:54
 TMatrixT.cxx:55
 TMatrixT.cxx:56
 TMatrixT.cxx:57
 TMatrixT.cxx:58
 TMatrixT.cxx:59
 TMatrixT.cxx:60
 TMatrixT.cxx:61
 TMatrixT.cxx:62
 TMatrixT.cxx:63
 TMatrixT.cxx:64
 TMatrixT.cxx:65
 TMatrixT.cxx:66
 TMatrixT.cxx:67
 TMatrixT.cxx:68
 TMatrixT.cxx:69
 TMatrixT.cxx:70
 TMatrixT.cxx:71
 TMatrixT.cxx:72
 TMatrixT.cxx:73
 TMatrixT.cxx:74
 TMatrixT.cxx:75
 TMatrixT.cxx:76
 TMatrixT.cxx:77
 TMatrixT.cxx:78
 TMatrixT.cxx:79
 TMatrixT.cxx:80
 TMatrixT.cxx:81
 TMatrixT.cxx:82
 TMatrixT.cxx:83
 TMatrixT.cxx:84
 TMatrixT.cxx:85
 TMatrixT.cxx:86
 TMatrixT.cxx:87
 TMatrixT.cxx:88
 TMatrixT.cxx:89
 TMatrixT.cxx:90
 TMatrixT.cxx:91
 TMatrixT.cxx:92
 TMatrixT.cxx:93
 TMatrixT.cxx:94
 TMatrixT.cxx:95
 TMatrixT.cxx:96
 TMatrixT.cxx:97
 TMatrixT.cxx:98
 TMatrixT.cxx:99
 TMatrixT.cxx:100
 TMatrixT.cxx:101
 TMatrixT.cxx:102
 TMatrixT.cxx:103
 TMatrixT.cxx:104
 TMatrixT.cxx:105
 TMatrixT.cxx:106
 TMatrixT.cxx:107
 TMatrixT.cxx:108
 TMatrixT.cxx:109
 TMatrixT.cxx:110
 TMatrixT.cxx:111
 TMatrixT.cxx:112
 TMatrixT.cxx:113
 TMatrixT.cxx:114
 TMatrixT.cxx:115
 TMatrixT.cxx:116
 TMatrixT.cxx:117
 TMatrixT.cxx:118
 TMatrixT.cxx:119
 TMatrixT.cxx:120
 TMatrixT.cxx:121
 TMatrixT.cxx:122
 TMatrixT.cxx:123
 TMatrixT.cxx:124
 TMatrixT.cxx:125
 TMatrixT.cxx:126
 TMatrixT.cxx:127
 TMatrixT.cxx:128
 TMatrixT.cxx:129
 TMatrixT.cxx:130
 TMatrixT.cxx:131
 TMatrixT.cxx:132
 TMatrixT.cxx:133
 TMatrixT.cxx:134
 TMatrixT.cxx:135
 TMatrixT.cxx:136
 TMatrixT.cxx:137
 TMatrixT.cxx:138
 TMatrixT.cxx:139
 TMatrixT.cxx:140
 TMatrixT.cxx:141
 TMatrixT.cxx:142
 TMatrixT.cxx:143
 TMatrixT.cxx:144
 TMatrixT.cxx:145
 TMatrixT.cxx:146
 TMatrixT.cxx:147
 TMatrixT.cxx:148
 TMatrixT.cxx:149
 TMatrixT.cxx:150
 TMatrixT.cxx:151
 TMatrixT.cxx:152
 TMatrixT.cxx:153
 TMatrixT.cxx:154
 TMatrixT.cxx:155
 TMatrixT.cxx:156
 TMatrixT.cxx:157
 TMatrixT.cxx:158
 TMatrixT.cxx:159
 TMatrixT.cxx:160
 TMatrixT.cxx:161
 TMatrixT.cxx:162
 TMatrixT.cxx:163
 TMatrixT.cxx:164
 TMatrixT.cxx:165
 TMatrixT.cxx:166
 TMatrixT.cxx:167
 TMatrixT.cxx:168
 TMatrixT.cxx:169
 TMatrixT.cxx:170
 TMatrixT.cxx:171
 TMatrixT.cxx:172
 TMatrixT.cxx:173
 TMatrixT.cxx:174
 TMatrixT.cxx:175
 TMatrixT.cxx:176
 TMatrixT.cxx:177
 TMatrixT.cxx:178
 TMatrixT.cxx:179
 TMatrixT.cxx:180
 TMatrixT.cxx:181
 TMatrixT.cxx:182
 TMatrixT.cxx:183
 TMatrixT.cxx:184
 TMatrixT.cxx:185
 TMatrixT.cxx:186
 TMatrixT.cxx:187
 TMatrixT.cxx:188
 TMatrixT.cxx:189
 TMatrixT.cxx:190
 TMatrixT.cxx:191
 TMatrixT.cxx:192
 TMatrixT.cxx:193
 TMatrixT.cxx:194
 TMatrixT.cxx:195
 TMatrixT.cxx:196
 TMatrixT.cxx:197
 TMatrixT.cxx:198
 TMatrixT.cxx:199
 TMatrixT.cxx:200
 TMatrixT.cxx:201
 TMatrixT.cxx:202
 TMatrixT.cxx:203
 TMatrixT.cxx:204
 TMatrixT.cxx:205
 TMatrixT.cxx:206
 TMatrixT.cxx:207
 TMatrixT.cxx:208
 TMatrixT.cxx:209
 TMatrixT.cxx:210
 TMatrixT.cxx:211
 TMatrixT.cxx:212
 TMatrixT.cxx:213
 TMatrixT.cxx:214
 TMatrixT.cxx:215
 TMatrixT.cxx:216
 TMatrixT.cxx:217
 TMatrixT.cxx:218
 TMatrixT.cxx:219
 TMatrixT.cxx:220
 TMatrixT.cxx:221
 TMatrixT.cxx:222
 TMatrixT.cxx:223
 TMatrixT.cxx:224
 TMatrixT.cxx:225
 TMatrixT.cxx:226
 TMatrixT.cxx:227
 TMatrixT.cxx:228
 TMatrixT.cxx:229
 TMatrixT.cxx:230
 TMatrixT.cxx:231
 TMatrixT.cxx:232
 TMatrixT.cxx:233
 TMatrixT.cxx:234
 TMatrixT.cxx:235
 TMatrixT.cxx:236
 TMatrixT.cxx:237
 TMatrixT.cxx:238
 TMatrixT.cxx:239
 TMatrixT.cxx:240
 TMatrixT.cxx:241
 TMatrixT.cxx:242
 TMatrixT.cxx:243
 TMatrixT.cxx:244
 TMatrixT.cxx:245
 TMatrixT.cxx:246
 TMatrixT.cxx:247
 TMatrixT.cxx:248
 TMatrixT.cxx:249
 TMatrixT.cxx:250
 TMatrixT.cxx:251
 TMatrixT.cxx:252
 TMatrixT.cxx:253
 TMatrixT.cxx:254
 TMatrixT.cxx:255
 TMatrixT.cxx:256
 TMatrixT.cxx:257
 TMatrixT.cxx:258
 TMatrixT.cxx:259
 TMatrixT.cxx:260
 TMatrixT.cxx:261
 TMatrixT.cxx:262
 TMatrixT.cxx:263
 TMatrixT.cxx:264
 TMatrixT.cxx:265
 TMatrixT.cxx:266
 TMatrixT.cxx:267
 TMatrixT.cxx:268
 TMatrixT.cxx:269
 TMatrixT.cxx:270
 TMatrixT.cxx:271
 TMatrixT.cxx:272
 TMatrixT.cxx:273
 TMatrixT.cxx:274
 TMatrixT.cxx:275
 TMatrixT.cxx:276
 TMatrixT.cxx:277
 TMatrixT.cxx:278
 TMatrixT.cxx:279
 TMatrixT.cxx:280
 TMatrixT.cxx:281
 TMatrixT.cxx:282
 TMatrixT.cxx:283
 TMatrixT.cxx:284
 TMatrixT.cxx:285
 TMatrixT.cxx:286
 TMatrixT.cxx:287
 TMatrixT.cxx:288
 TMatrixT.cxx:289
 TMatrixT.cxx:290
 TMatrixT.cxx:291
 TMatrixT.cxx:292
 TMatrixT.cxx:293
 TMatrixT.cxx:294
 TMatrixT.cxx:295
 TMatrixT.cxx:296
 TMatrixT.cxx:297
 TMatrixT.cxx:298
 TMatrixT.cxx:299
 TMatrixT.cxx:300
 TMatrixT.cxx:301
 TMatrixT.cxx:302
 TMatrixT.cxx:303
 TMatrixT.cxx:304
 TMatrixT.cxx:305
 TMatrixT.cxx:306
 TMatrixT.cxx:307
 TMatrixT.cxx:308
 TMatrixT.cxx:309
 TMatrixT.cxx:310
 TMatrixT.cxx:311
 TMatrixT.cxx:312
 TMatrixT.cxx:313
 TMatrixT.cxx:314
 TMatrixT.cxx:315
 TMatrixT.cxx:316
 TMatrixT.cxx:317
 TMatrixT.cxx:318
 TMatrixT.cxx:319
 TMatrixT.cxx:320
 TMatrixT.cxx:321
 TMatrixT.cxx:322
 TMatrixT.cxx:323
 TMatrixT.cxx:324
 TMatrixT.cxx:325
 TMatrixT.cxx:326
 TMatrixT.cxx:327
 TMatrixT.cxx:328
 TMatrixT.cxx:329
 TMatrixT.cxx:330
 TMatrixT.cxx:331
 TMatrixT.cxx:332
 TMatrixT.cxx:333
 TMatrixT.cxx:334
 TMatrixT.cxx:335
 TMatrixT.cxx:336
 TMatrixT.cxx:337
 TMatrixT.cxx:338
 TMatrixT.cxx:339
 TMatrixT.cxx:340
 TMatrixT.cxx:341
 TMatrixT.cxx:342
 TMatrixT.cxx:343
 TMatrixT.cxx:344
 TMatrixT.cxx:345
 TMatrixT.cxx:346
 TMatrixT.cxx:347
 TMatrixT.cxx:348
 TMatrixT.cxx:349
 TMatrixT.cxx:350
 TMatrixT.cxx:351
 TMatrixT.cxx:352
 TMatrixT.cxx:353
 TMatrixT.cxx:354
 TMatrixT.cxx:355
 TMatrixT.cxx:356
 TMatrixT.cxx:357
 TMatrixT.cxx:358
 TMatrixT.cxx:359
 TMatrixT.cxx:360
 TMatrixT.cxx:361
 TMatrixT.cxx:362
 TMatrixT.cxx:363
 TMatrixT.cxx:364
 TMatrixT.cxx:365
 TMatrixT.cxx:366
 TMatrixT.cxx:367
 TMatrixT.cxx:368
 TMatrixT.cxx:369
 TMatrixT.cxx:370
 TMatrixT.cxx:371
 TMatrixT.cxx:372
 TMatrixT.cxx:373
 TMatrixT.cxx:374
 TMatrixT.cxx:375
 TMatrixT.cxx:376
 TMatrixT.cxx:377
 TMatrixT.cxx:378
 TMatrixT.cxx:379
 TMatrixT.cxx:380
 TMatrixT.cxx:381
 TMatrixT.cxx:382
 TMatrixT.cxx:383
 TMatrixT.cxx:384
 TMatrixT.cxx:385
 TMatrixT.cxx:386
 TMatrixT.cxx:387
 TMatrixT.cxx:388
 TMatrixT.cxx:389
 TMatrixT.cxx:390
 TMatrixT.cxx:391
 TMatrixT.cxx:392
 TMatrixT.cxx:393
 TMatrixT.cxx:394
 TMatrixT.cxx:395
 TMatrixT.cxx:396
 TMatrixT.cxx:397
 TMatrixT.cxx:398
 TMatrixT.cxx:399
 TMatrixT.cxx:400
 TMatrixT.cxx:401
 TMatrixT.cxx:402
 TMatrixT.cxx:403
 TMatrixT.cxx:404
 TMatrixT.cxx:405
 TMatrixT.cxx:406
 TMatrixT.cxx:407
 TMatrixT.cxx:408
 TMatrixT.cxx:409
 TMatrixT.cxx:410
 TMatrixT.cxx:411
 TMatrixT.cxx:412
 TMatrixT.cxx:413
 TMatrixT.cxx:414
 TMatrixT.cxx:415
 TMatrixT.cxx:416
 TMatrixT.cxx:417
 TMatrixT.cxx:418
 TMatrixT.cxx:419
 TMatrixT.cxx:420
 TMatrixT.cxx:421
 TMatrixT.cxx:422
 TMatrixT.cxx:423
 TMatrixT.cxx:424
 TMatrixT.cxx:425
 TMatrixT.cxx:426
 TMatrixT.cxx:427
 TMatrixT.cxx:428
 TMatrixT.cxx:429
 TMatrixT.cxx:430
 TMatrixT.cxx:431
 TMatrixT.cxx:432
 TMatrixT.cxx:433
 TMatrixT.cxx:434
 TMatrixT.cxx:435
 TMatrixT.cxx:436
 TMatrixT.cxx:437
 TMatrixT.cxx:438
 TMatrixT.cxx:439
 TMatrixT.cxx:440
 TMatrixT.cxx:441
 TMatrixT.cxx:442
 TMatrixT.cxx:443
 TMatrixT.cxx:444
 TMatrixT.cxx:445
 TMatrixT.cxx:446
 TMatrixT.cxx:447
 TMatrixT.cxx:448
 TMatrixT.cxx:449
 TMatrixT.cxx:450
 TMatrixT.cxx:451
 TMatrixT.cxx:452
 TMatrixT.cxx:453
 TMatrixT.cxx:454
 TMatrixT.cxx:455
 TMatrixT.cxx:456
 TMatrixT.cxx:457
 TMatrixT.cxx:458
 TMatrixT.cxx:459
 TMatrixT.cxx:460
 TMatrixT.cxx:461
 TMatrixT.cxx:462
 TMatrixT.cxx:463
 TMatrixT.cxx:464
 TMatrixT.cxx:465
 TMatrixT.cxx:466
 TMatrixT.cxx:467
 TMatrixT.cxx:468
 TMatrixT.cxx:469
 TMatrixT.cxx:470
 TMatrixT.cxx:471
 TMatrixT.cxx:472
 TMatrixT.cxx:473
 TMatrixT.cxx:474
 TMatrixT.cxx:475
 TMatrixT.cxx:476
 TMatrixT.cxx:477
 TMatrixT.cxx:478
 TMatrixT.cxx:479
 TMatrixT.cxx:480
 TMatrixT.cxx:481
 TMatrixT.cxx:482
 TMatrixT.cxx:483
 TMatrixT.cxx:484
 TMatrixT.cxx:485
 TMatrixT.cxx:486
 TMatrixT.cxx:487
 TMatrixT.cxx:488
 TMatrixT.cxx:489
 TMatrixT.cxx:490
 TMatrixT.cxx:491
 TMatrixT.cxx:492
 TMatrixT.cxx:493
 TMatrixT.cxx:494
 TMatrixT.cxx:495
 TMatrixT.cxx:496
 TMatrixT.cxx:497
 TMatrixT.cxx:498
 TMatrixT.cxx:499
 TMatrixT.cxx:500
 TMatrixT.cxx:501
 TMatrixT.cxx:502
 TMatrixT.cxx:503
 TMatrixT.cxx:504
 TMatrixT.cxx:505
 TMatrixT.cxx:506
 TMatrixT.cxx:507
 TMatrixT.cxx:508
 TMatrixT.cxx:509
 TMatrixT.cxx:510
 TMatrixT.cxx:511
 TMatrixT.cxx:512
 TMatrixT.cxx:513
 TMatrixT.cxx:514
 TMatrixT.cxx:515
 TMatrixT.cxx:516
 TMatrixT.cxx:517
 TMatrixT.cxx:518
 TMatrixT.cxx:519
 TMatrixT.cxx:520
 TMatrixT.cxx:521
 TMatrixT.cxx:522
 TMatrixT.cxx:523
 TMatrixT.cxx:524
 TMatrixT.cxx:525
 TMatrixT.cxx:526
 TMatrixT.cxx:527
 TMatrixT.cxx:528
 TMatrixT.cxx:529
 TMatrixT.cxx:530
 TMatrixT.cxx:531
 TMatrixT.cxx:532
 TMatrixT.cxx:533
 TMatrixT.cxx:534
 TMatrixT.cxx:535
 TMatrixT.cxx:536
 TMatrixT.cxx:537
 TMatrixT.cxx:538
 TMatrixT.cxx:539
 TMatrixT.cxx:540
 TMatrixT.cxx:541
 TMatrixT.cxx:542
 TMatrixT.cxx:543
 TMatrixT.cxx:544
 TMatrixT.cxx:545
 TMatrixT.cxx:546
 TMatrixT.cxx:547
 TMatrixT.cxx:548
 TMatrixT.cxx:549
 TMatrixT.cxx:550
 TMatrixT.cxx:551
 TMatrixT.cxx:552
 TMatrixT.cxx:553
 TMatrixT.cxx:554
 TMatrixT.cxx:555
 TMatrixT.cxx:556
 TMatrixT.cxx:557
 TMatrixT.cxx:558
 TMatrixT.cxx:559
 TMatrixT.cxx:560
 TMatrixT.cxx:561
 TMatrixT.cxx:562
 TMatrixT.cxx:563
 TMatrixT.cxx:564
 TMatrixT.cxx:565
 TMatrixT.cxx:566
 TMatrixT.cxx:567
 TMatrixT.cxx:568
 TMatrixT.cxx:569
 TMatrixT.cxx:570
 TMatrixT.cxx:571
 TMatrixT.cxx:572
 TMatrixT.cxx:573
 TMatrixT.cxx:574
 TMatrixT.cxx:575
 TMatrixT.cxx:576
 TMatrixT.cxx:577
 TMatrixT.cxx:578
 TMatrixT.cxx:579
 TMatrixT.cxx:580
 TMatrixT.cxx:581
 TMatrixT.cxx:582
 TMatrixT.cxx:583
 TMatrixT.cxx:584
 TMatrixT.cxx:585
 TMatrixT.cxx:586
 TMatrixT.cxx:587
 TMatrixT.cxx:588
 TMatrixT.cxx:589
 TMatrixT.cxx:590
 TMatrixT.cxx:591
 TMatrixT.cxx:592
 TMatrixT.cxx:593
 TMatrixT.cxx:594
 TMatrixT.cxx:595
 TMatrixT.cxx:596
 TMatrixT.cxx:597
 TMatrixT.cxx:598
 TMatrixT.cxx:599
 TMatrixT.cxx:600
 TMatrixT.cxx:601
 TMatrixT.cxx:602
 TMatrixT.cxx:603
 TMatrixT.cxx:604
 TMatrixT.cxx:605
 TMatrixT.cxx:606
 TMatrixT.cxx:607
 TMatrixT.cxx:608
 TMatrixT.cxx:609
 TMatrixT.cxx:610
 TMatrixT.cxx:611
 TMatrixT.cxx:612
 TMatrixT.cxx:613
 TMatrixT.cxx:614
 TMatrixT.cxx:615
 TMatrixT.cxx:616
 TMatrixT.cxx:617
 TMatrixT.cxx:618
 TMatrixT.cxx:619
 TMatrixT.cxx:620
 TMatrixT.cxx:621
 TMatrixT.cxx:622
 TMatrixT.cxx:623
 TMatrixT.cxx:624
 TMatrixT.cxx:625
 TMatrixT.cxx:626
 TMatrixT.cxx:627
 TMatrixT.cxx:628
 TMatrixT.cxx:629
 TMatrixT.cxx:630
 TMatrixT.cxx:631
 TMatrixT.cxx:632
 TMatrixT.cxx:633
 TMatrixT.cxx:634
 TMatrixT.cxx:635
 TMatrixT.cxx:636
 TMatrixT.cxx:637
 TMatrixT.cxx:638
 TMatrixT.cxx:639
 TMatrixT.cxx:640
 TMatrixT.cxx:641
 TMatrixT.cxx:642
 TMatrixT.cxx:643
 TMatrixT.cxx:644
 TMatrixT.cxx:645
 TMatrixT.cxx:646
 TMatrixT.cxx:647
 TMatrixT.cxx:648
 TMatrixT.cxx:649
 TMatrixT.cxx:650
 TMatrixT.cxx:651
 TMatrixT.cxx:652
 TMatrixT.cxx:653
 TMatrixT.cxx:654
 TMatrixT.cxx:655
 TMatrixT.cxx:656
 TMatrixT.cxx:657
 TMatrixT.cxx:658
 TMatrixT.cxx:659
 TMatrixT.cxx:660
 TMatrixT.cxx:661
 TMatrixT.cxx:662
 TMatrixT.cxx:663
 TMatrixT.cxx:664
 TMatrixT.cxx:665
 TMatrixT.cxx:666
 TMatrixT.cxx:667
 TMatrixT.cxx:668
 TMatrixT.cxx:669
 TMatrixT.cxx:670
 TMatrixT.cxx:671
 TMatrixT.cxx:672
 TMatrixT.cxx:673
 TMatrixT.cxx:674
 TMatrixT.cxx:675
 TMatrixT.cxx:676
 TMatrixT.cxx:677
 TMatrixT.cxx:678
 TMatrixT.cxx:679
 TMatrixT.cxx:680
 TMatrixT.cxx:681
 TMatrixT.cxx:682
 TMatrixT.cxx:683
 TMatrixT.cxx:684
 TMatrixT.cxx:685
 TMatrixT.cxx:686
 TMatrixT.cxx:687
 TMatrixT.cxx:688
 TMatrixT.cxx:689
 TMatrixT.cxx:690
 TMatrixT.cxx:691
 TMatrixT.cxx:692
 TMatrixT.cxx:693
 TMatrixT.cxx:694
 TMatrixT.cxx:695
 TMatrixT.cxx:696
 TMatrixT.cxx:697
 TMatrixT.cxx:698
 TMatrixT.cxx:699
 TMatrixT.cxx:700
 TMatrixT.cxx:701
 TMatrixT.cxx:702
 TMatrixT.cxx:703
 TMatrixT.cxx:704
 TMatrixT.cxx:705
 TMatrixT.cxx:706
 TMatrixT.cxx:707
 TMatrixT.cxx:708
 TMatrixT.cxx:709
 TMatrixT.cxx:710
 TMatrixT.cxx:711
 TMatrixT.cxx:712
 TMatrixT.cxx:713
 TMatrixT.cxx:714
 TMatrixT.cxx:715
 TMatrixT.cxx:716
 TMatrixT.cxx:717
 TMatrixT.cxx:718
 TMatrixT.cxx:719
 TMatrixT.cxx:720
 TMatrixT.cxx:721
 TMatrixT.cxx:722
 TMatrixT.cxx:723
 TMatrixT.cxx:724
 TMatrixT.cxx:725
 TMatrixT.cxx:726
 TMatrixT.cxx:727
 TMatrixT.cxx:728
 TMatrixT.cxx:729
 TMatrixT.cxx:730
 TMatrixT.cxx:731
 TMatrixT.cxx:732
 TMatrixT.cxx:733
 TMatrixT.cxx:734
 TMatrixT.cxx:735
 TMatrixT.cxx:736
 TMatrixT.cxx:737
 TMatrixT.cxx:738
 TMatrixT.cxx:739
 TMatrixT.cxx:740
 TMatrixT.cxx:741
 TMatrixT.cxx:742
 TMatrixT.cxx:743
 TMatrixT.cxx:744
 TMatrixT.cxx:745
 TMatrixT.cxx:746
 TMatrixT.cxx:747
 TMatrixT.cxx:748
 TMatrixT.cxx:749
 TMatrixT.cxx:750
 TMatrixT.cxx:751
 TMatrixT.cxx:752
 TMatrixT.cxx:753
 TMatrixT.cxx:754
 TMatrixT.cxx:755
 TMatrixT.cxx:756
 TMatrixT.cxx:757
 TMatrixT.cxx:758
 TMatrixT.cxx:759
 TMatrixT.cxx:760
 TMatrixT.cxx:761
 TMatrixT.cxx:762
 TMatrixT.cxx:763
 TMatrixT.cxx:764
 TMatrixT.cxx:765
 TMatrixT.cxx:766
 TMatrixT.cxx:767
 TMatrixT.cxx:768
 TMatrixT.cxx:769
 TMatrixT.cxx:770
 TMatrixT.cxx:771
 TMatrixT.cxx:772
 TMatrixT.cxx:773
 TMatrixT.cxx:774
 TMatrixT.cxx:775
 TMatrixT.cxx:776
 TMatrixT.cxx:777
 TMatrixT.cxx:778
 TMatrixT.cxx:779
 TMatrixT.cxx:780
 TMatrixT.cxx:781
 TMatrixT.cxx:782
 TMatrixT.cxx:783
 TMatrixT.cxx:784
 TMatrixT.cxx:785
 TMatrixT.cxx:786
 TMatrixT.cxx:787
 TMatrixT.cxx:788
 TMatrixT.cxx:789
 TMatrixT.cxx:790
 TMatrixT.cxx:791
 TMatrixT.cxx:792
 TMatrixT.cxx:793
 TMatrixT.cxx:794
 TMatrixT.cxx:795
 TMatrixT.cxx:796
 TMatrixT.cxx:797
 TMatrixT.cxx:798
 TMatrixT.cxx:799
 TMatrixT.cxx:800
 TMatrixT.cxx:801
 TMatrixT.cxx:802
 TMatrixT.cxx:803
 TMatrixT.cxx:804
 TMatrixT.cxx:805
 TMatrixT.cxx:806
 TMatrixT.cxx:807
 TMatrixT.cxx:808
 TMatrixT.cxx:809
 TMatrixT.cxx:810
 TMatrixT.cxx:811
 TMatrixT.cxx:812
 TMatrixT.cxx:813
 TMatrixT.cxx:814
 TMatrixT.cxx:815
 TMatrixT.cxx:816
 TMatrixT.cxx:817
 TMatrixT.cxx:818
 TMatrixT.cxx:819
 TMatrixT.cxx:820
 TMatrixT.cxx:821
 TMatrixT.cxx:822
 TMatrixT.cxx:823
 TMatrixT.cxx:824
 TMatrixT.cxx:825
 TMatrixT.cxx:826
 TMatrixT.cxx:827
 TMatrixT.cxx:828
 TMatrixT.cxx:829
 TMatrixT.cxx:830
 TMatrixT.cxx:831
 TMatrixT.cxx:832
 TMatrixT.cxx:833
 TMatrixT.cxx:834
 TMatrixT.cxx:835
 TMatrixT.cxx:836
 TMatrixT.cxx:837
 TMatrixT.cxx:838
 TMatrixT.cxx:839
 TMatrixT.cxx:840
 TMatrixT.cxx:841
 TMatrixT.cxx:842
 TMatrixT.cxx:843
 TMatrixT.cxx:844
 TMatrixT.cxx:845
 TMatrixT.cxx:846
 TMatrixT.cxx:847
 TMatrixT.cxx:848
 TMatrixT.cxx:849
 TMatrixT.cxx:850
 TMatrixT.cxx:851
 TMatrixT.cxx:852
 TMatrixT.cxx:853
 TMatrixT.cxx:854
 TMatrixT.cxx:855
 TMatrixT.cxx:856
 TMatrixT.cxx:857
 TMatrixT.cxx:858
 TMatrixT.cxx:859
 TMatrixT.cxx:860
 TMatrixT.cxx:861
 TMatrixT.cxx:862
 TMatrixT.cxx:863
 TMatrixT.cxx:864
 TMatrixT.cxx:865
 TMatrixT.cxx:866
 TMatrixT.cxx:867
 TMatrixT.cxx:868
 TMatrixT.cxx:869
 TMatrixT.cxx:870
 TMatrixT.cxx:871
 TMatrixT.cxx:872
 TMatrixT.cxx:873
 TMatrixT.cxx:874
 TMatrixT.cxx:875
 TMatrixT.cxx:876
 TMatrixT.cxx:877
 TMatrixT.cxx:878
 TMatrixT.cxx:879
 TMatrixT.cxx:880
 TMatrixT.cxx:881
 TMatrixT.cxx:882
 TMatrixT.cxx:883
 TMatrixT.cxx:884
 TMatrixT.cxx:885
 TMatrixT.cxx:886
 TMatrixT.cxx:887
 TMatrixT.cxx:888
 TMatrixT.cxx:889
 TMatrixT.cxx:890
 TMatrixT.cxx:891
 TMatrixT.cxx:892
 TMatrixT.cxx:893
 TMatrixT.cxx:894
 TMatrixT.cxx:895
 TMatrixT.cxx:896
 TMatrixT.cxx:897
 TMatrixT.cxx:898
 TMatrixT.cxx:899
 TMatrixT.cxx:900
 TMatrixT.cxx:901
 TMatrixT.cxx:902
 TMatrixT.cxx:903
 TMatrixT.cxx:904
 TMatrixT.cxx:905
 TMatrixT.cxx:906
 TMatrixT.cxx:907
 TMatrixT.cxx:908
 TMatrixT.cxx:909
 TMatrixT.cxx:910
 TMatrixT.cxx:911
 TMatrixT.cxx:912
 TMatrixT.cxx:913
 TMatrixT.cxx:914
 TMatrixT.cxx:915
 TMatrixT.cxx:916
 TMatrixT.cxx:917
 TMatrixT.cxx:918
 TMatrixT.cxx:919
 TMatrixT.cxx:920
 TMatrixT.cxx:921
 TMatrixT.cxx:922
 TMatrixT.cxx:923
 TMatrixT.cxx:924
 TMatrixT.cxx:925
 TMatrixT.cxx:926
 TMatrixT.cxx:927
 TMatrixT.cxx:928
 TMatrixT.cxx:929
 TMatrixT.cxx:930
 TMatrixT.cxx:931
 TMatrixT.cxx:932
 TMatrixT.cxx:933
 TMatrixT.cxx:934
 TMatrixT.cxx:935
 TMatrixT.cxx:936
 TMatrixT.cxx:937
 TMatrixT.cxx:938
 TMatrixT.cxx:939
 TMatrixT.cxx:940
 TMatrixT.cxx:941
 TMatrixT.cxx:942
 TMatrixT.cxx:943
 TMatrixT.cxx:944
 TMatrixT.cxx:945
 TMatrixT.cxx:946
 TMatrixT.cxx:947
 TMatrixT.cxx:948
 TMatrixT.cxx:949
 TMatrixT.cxx:950
 TMatrixT.cxx:951
 TMatrixT.cxx:952
 TMatrixT.cxx:953
 TMatrixT.cxx:954
 TMatrixT.cxx:955
 TMatrixT.cxx:956
 TMatrixT.cxx:957
 TMatrixT.cxx:958
 TMatrixT.cxx:959
 TMatrixT.cxx:960
 TMatrixT.cxx:961
 TMatrixT.cxx:962
 TMatrixT.cxx:963
 TMatrixT.cxx:964
 TMatrixT.cxx:965
 TMatrixT.cxx:966
 TMatrixT.cxx:967
 TMatrixT.cxx:968
 TMatrixT.cxx:969
 TMatrixT.cxx:970
 TMatrixT.cxx:971
 TMatrixT.cxx:972
 TMatrixT.cxx:973
 TMatrixT.cxx:974
 TMatrixT.cxx:975
 TMatrixT.cxx:976
 TMatrixT.cxx:977
 TMatrixT.cxx:978
 TMatrixT.cxx:979
 TMatrixT.cxx:980
 TMatrixT.cxx:981
 TMatrixT.cxx:982
 TMatrixT.cxx:983
 TMatrixT.cxx:984
 TMatrixT.cxx:985
 TMatrixT.cxx:986
 TMatrixT.cxx:987
 TMatrixT.cxx:988
 TMatrixT.cxx:989
 TMatrixT.cxx:990
 TMatrixT.cxx:991
 TMatrixT.cxx:992
 TMatrixT.cxx:993
 TMatrixT.cxx:994
 TMatrixT.cxx:995
 TMatrixT.cxx:996
 TMatrixT.cxx:997
 TMatrixT.cxx:998
 TMatrixT.cxx:999
 TMatrixT.cxx:1000
 TMatrixT.cxx:1001
 TMatrixT.cxx:1002
 TMatrixT.cxx:1003
 TMatrixT.cxx:1004
 TMatrixT.cxx:1005
 TMatrixT.cxx:1006
 TMatrixT.cxx:1007
 TMatrixT.cxx:1008
 TMatrixT.cxx:1009
 TMatrixT.cxx:1010
 TMatrixT.cxx:1011
 TMatrixT.cxx:1012
 TMatrixT.cxx:1013
 TMatrixT.cxx:1014
 TMatrixT.cxx:1015
 TMatrixT.cxx:1016
 TMatrixT.cxx:1017
 TMatrixT.cxx:1018
 TMatrixT.cxx:1019
 TMatrixT.cxx:1020
 TMatrixT.cxx:1021
 TMatrixT.cxx:1022
 TMatrixT.cxx:1023
 TMatrixT.cxx:1024
 TMatrixT.cxx:1025
 TMatrixT.cxx:1026
 TMatrixT.cxx:1027
 TMatrixT.cxx:1028
 TMatrixT.cxx:1029
 TMatrixT.cxx:1030
 TMatrixT.cxx:1031
 TMatrixT.cxx:1032
 TMatrixT.cxx:1033
 TMatrixT.cxx:1034
 TMatrixT.cxx:1035
 TMatrixT.cxx:1036
 TMatrixT.cxx:1037
 TMatrixT.cxx:1038
 TMatrixT.cxx:1039
 TMatrixT.cxx:1040
 TMatrixT.cxx:1041
 TMatrixT.cxx:1042
 TMatrixT.cxx:1043
 TMatrixT.cxx:1044
 TMatrixT.cxx:1045
 TMatrixT.cxx:1046
 TMatrixT.cxx:1047
 TMatrixT.cxx:1048
 TMatrixT.cxx:1049
 TMatrixT.cxx:1050
 TMatrixT.cxx:1051
 TMatrixT.cxx:1052
 TMatrixT.cxx:1053
 TMatrixT.cxx:1054
 TMatrixT.cxx:1055
 TMatrixT.cxx:1056
 TMatrixT.cxx:1057
 TMatrixT.cxx:1058
 TMatrixT.cxx:1059
 TMatrixT.cxx:1060
 TMatrixT.cxx:1061
 TMatrixT.cxx:1062
 TMatrixT.cxx:1063
 TMatrixT.cxx:1064
 TMatrixT.cxx:1065
 TMatrixT.cxx:1066
 TMatrixT.cxx:1067
 TMatrixT.cxx:1068
 TMatrixT.cxx:1069
 TMatrixT.cxx:1070
 TMatrixT.cxx:1071
 TMatrixT.cxx:1072
 TMatrixT.cxx:1073
 TMatrixT.cxx:1074
 TMatrixT.cxx:1075
 TMatrixT.cxx:1076
 TMatrixT.cxx:1077
 TMatrixT.cxx:1078
 TMatrixT.cxx:1079
 TMatrixT.cxx:1080
 TMatrixT.cxx:1081
 TMatrixT.cxx:1082
 TMatrixT.cxx:1083
 TMatrixT.cxx:1084
 TMatrixT.cxx:1085
 TMatrixT.cxx:1086
 TMatrixT.cxx:1087
 TMatrixT.cxx:1088
 TMatrixT.cxx:1089
 TMatrixT.cxx:1090
 TMatrixT.cxx:1091
 TMatrixT.cxx:1092
 TMatrixT.cxx:1093
 TMatrixT.cxx:1094
 TMatrixT.cxx:1095
 TMatrixT.cxx:1096
 TMatrixT.cxx:1097
 TMatrixT.cxx:1098
 TMatrixT.cxx:1099
 TMatrixT.cxx:1100
 TMatrixT.cxx:1101
 TMatrixT.cxx:1102
 TMatrixT.cxx:1103
 TMatrixT.cxx:1104
 TMatrixT.cxx:1105
 TMatrixT.cxx:1106
 TMatrixT.cxx:1107
 TMatrixT.cxx:1108
 TMatrixT.cxx:1109
 TMatrixT.cxx:1110
 TMatrixT.cxx:1111
 TMatrixT.cxx:1112
 TMatrixT.cxx:1113
 TMatrixT.cxx:1114
 TMatrixT.cxx:1115
 TMatrixT.cxx:1116
 TMatrixT.cxx:1117
 TMatrixT.cxx:1118
 TMatrixT.cxx:1119
 TMatrixT.cxx:1120
 TMatrixT.cxx:1121
 TMatrixT.cxx:1122
 TMatrixT.cxx:1123
 TMatrixT.cxx:1124
 TMatrixT.cxx:1125
 TMatrixT.cxx:1126
 TMatrixT.cxx:1127
 TMatrixT.cxx:1128
 TMatrixT.cxx:1129
 TMatrixT.cxx:1130
 TMatrixT.cxx:1131
 TMatrixT.cxx:1132
 TMatrixT.cxx:1133
 TMatrixT.cxx:1134
 TMatrixT.cxx:1135
 TMatrixT.cxx:1136
 TMatrixT.cxx:1137
 TMatrixT.cxx:1138
 TMatrixT.cxx:1139
 TMatrixT.cxx:1140
 TMatrixT.cxx:1141
 TMatrixT.cxx:1142
 TMatrixT.cxx:1143
 TMatrixT.cxx:1144
 TMatrixT.cxx:1145
 TMatrixT.cxx:1146
 TMatrixT.cxx:1147
 TMatrixT.cxx:1148
 TMatrixT.cxx:1149
 TMatrixT.cxx:1150
 TMatrixT.cxx:1151
 TMatrixT.cxx:1152
 TMatrixT.cxx:1153
 TMatrixT.cxx:1154
 TMatrixT.cxx:1155
 TMatrixT.cxx:1156
 TMatrixT.cxx:1157
 TMatrixT.cxx:1158
 TMatrixT.cxx:1159
 TMatrixT.cxx:1160
 TMatrixT.cxx:1161
 TMatrixT.cxx:1162
 TMatrixT.cxx:1163
 TMatrixT.cxx:1164
 TMatrixT.cxx:1165
 TMatrixT.cxx:1166
 TMatrixT.cxx:1167
 TMatrixT.cxx:1168
 TMatrixT.cxx:1169
 TMatrixT.cxx:1170
 TMatrixT.cxx:1171
 TMatrixT.cxx:1172
 TMatrixT.cxx:1173
 TMatrixT.cxx:1174
 TMatrixT.cxx:1175
 TMatrixT.cxx:1176
 TMatrixT.cxx:1177
 TMatrixT.cxx:1178
 TMatrixT.cxx:1179
 TMatrixT.cxx:1180
 TMatrixT.cxx:1181
 TMatrixT.cxx:1182
 TMatrixT.cxx:1183
 TMatrixT.cxx:1184
 TMatrixT.cxx:1185
 TMatrixT.cxx:1186
 TMatrixT.cxx:1187
 TMatrixT.cxx:1188
 TMatrixT.cxx:1189
 TMatrixT.cxx:1190
 TMatrixT.cxx:1191
 TMatrixT.cxx:1192
 TMatrixT.cxx:1193
 TMatrixT.cxx:1194
 TMatrixT.cxx:1195
 TMatrixT.cxx:1196
 TMatrixT.cxx:1197
 TMatrixT.cxx:1198
 TMatrixT.cxx:1199
 TMatrixT.cxx:1200
 TMatrixT.cxx:1201
 TMatrixT.cxx:1202
 TMatrixT.cxx:1203
 TMatrixT.cxx:1204
 TMatrixT.cxx:1205
 TMatrixT.cxx:1206
 TMatrixT.cxx:1207
 TMatrixT.cxx:1208
 TMatrixT.cxx:1209
 TMatrixT.cxx:1210
 TMatrixT.cxx:1211
 TMatrixT.cxx:1212
 TMatrixT.cxx:1213
 TMatrixT.cxx:1214
 TMatrixT.cxx:1215
 TMatrixT.cxx:1216
 TMatrixT.cxx:1217
 TMatrixT.cxx:1218
 TMatrixT.cxx:1219
 TMatrixT.cxx:1220
 TMatrixT.cxx:1221
 TMatrixT.cxx:1222
 TMatrixT.cxx:1223
 TMatrixT.cxx:1224
 TMatrixT.cxx:1225
 TMatrixT.cxx:1226
 TMatrixT.cxx:1227
 TMatrixT.cxx:1228
 TMatrixT.cxx:1229
 TMatrixT.cxx:1230
 TMatrixT.cxx:1231
 TMatrixT.cxx:1232
 TMatrixT.cxx:1233
 TMatrixT.cxx:1234
 TMatrixT.cxx:1235
 TMatrixT.cxx:1236
 TMatrixT.cxx:1237
 TMatrixT.cxx:1238
 TMatrixT.cxx:1239
 TMatrixT.cxx:1240
 TMatrixT.cxx:1241
 TMatrixT.cxx:1242
 TMatrixT.cxx:1243
 TMatrixT.cxx:1244
 TMatrixT.cxx:1245
 TMatrixT.cxx:1246
 TMatrixT.cxx:1247
 TMatrixT.cxx:1248
 TMatrixT.cxx:1249
 TMatrixT.cxx:1250
 TMatrixT.cxx:1251
 TMatrixT.cxx:1252
 TMatrixT.cxx:1253
 TMatrixT.cxx:1254
 TMatrixT.cxx:1255
 TMatrixT.cxx:1256
 TMatrixT.cxx:1257
 TMatrixT.cxx:1258
 TMatrixT.cxx:1259
 TMatrixT.cxx:1260
 TMatrixT.cxx:1261
 TMatrixT.cxx:1262
 TMatrixT.cxx:1263
 TMatrixT.cxx:1264
 TMatrixT.cxx:1265
 TMatrixT.cxx:1266
 TMatrixT.cxx:1267
 TMatrixT.cxx:1268
 TMatrixT.cxx:1269
 TMatrixT.cxx:1270
 TMatrixT.cxx:1271
 TMatrixT.cxx:1272
 TMatrixT.cxx:1273
 TMatrixT.cxx:1274
 TMatrixT.cxx:1275
 TMatrixT.cxx:1276
 TMatrixT.cxx:1277
 TMatrixT.cxx:1278
 TMatrixT.cxx:1279
 TMatrixT.cxx:1280
 TMatrixT.cxx:1281
 TMatrixT.cxx:1282
 TMatrixT.cxx:1283
 TMatrixT.cxx:1284
 TMatrixT.cxx:1285
 TMatrixT.cxx:1286
 TMatrixT.cxx:1287
 TMatrixT.cxx:1288
 TMatrixT.cxx:1289
 TMatrixT.cxx:1290
 TMatrixT.cxx:1291
 TMatrixT.cxx:1292
 TMatrixT.cxx:1293
 TMatrixT.cxx:1294
 TMatrixT.cxx:1295
 TMatrixT.cxx:1296
 TMatrixT.cxx:1297
 TMatrixT.cxx:1298
 TMatrixT.cxx:1299
 TMatrixT.cxx:1300
 TMatrixT.cxx:1301
 TMatrixT.cxx:1302
 TMatrixT.cxx:1303
 TMatrixT.cxx:1304
 TMatrixT.cxx:1305
 TMatrixT.cxx:1306
 TMatrixT.cxx:1307
 TMatrixT.cxx:1308
 TMatrixT.cxx:1309
 TMatrixT.cxx:1310
 TMatrixT.cxx:1311
 TMatrixT.cxx:1312
 TMatrixT.cxx:1313
 TMatrixT.cxx:1314
 TMatrixT.cxx:1315
 TMatrixT.cxx:1316
 TMatrixT.cxx:1317
 TMatrixT.cxx:1318
 TMatrixT.cxx:1319
 TMatrixT.cxx:1320
 TMatrixT.cxx:1321
 TMatrixT.cxx:1322
 TMatrixT.cxx:1323
 TMatrixT.cxx:1324
 TMatrixT.cxx:1325
 TMatrixT.cxx:1326
 TMatrixT.cxx:1327
 TMatrixT.cxx:1328
 TMatrixT.cxx:1329
 TMatrixT.cxx:1330
 TMatrixT.cxx:1331
 TMatrixT.cxx:1332
 TMatrixT.cxx:1333
 TMatrixT.cxx:1334
 TMatrixT.cxx:1335
 TMatrixT.cxx:1336
 TMatrixT.cxx:1337
 TMatrixT.cxx:1338
 TMatrixT.cxx:1339
 TMatrixT.cxx:1340
 TMatrixT.cxx:1341
 TMatrixT.cxx:1342
 TMatrixT.cxx:1343
 TMatrixT.cxx:1344
 TMatrixT.cxx:1345
 TMatrixT.cxx:1346
 TMatrixT.cxx:1347
 TMatrixT.cxx:1348
 TMatrixT.cxx:1349
 TMatrixT.cxx:1350
 TMatrixT.cxx:1351
 TMatrixT.cxx:1352
 TMatrixT.cxx:1353
 TMatrixT.cxx:1354
 TMatrixT.cxx:1355
 TMatrixT.cxx:1356
 TMatrixT.cxx:1357
 TMatrixT.cxx:1358
 TMatrixT.cxx:1359
 TMatrixT.cxx:1360
 TMatrixT.cxx:1361
 TMatrixT.cxx:1362
 TMatrixT.cxx:1363
 TMatrixT.cxx:1364
 TMatrixT.cxx:1365
 TMatrixT.cxx:1366
 TMatrixT.cxx:1367
 TMatrixT.cxx:1368
 TMatrixT.cxx:1369
 TMatrixT.cxx:1370
 TMatrixT.cxx:1371
 TMatrixT.cxx:1372
 TMatrixT.cxx:1373
 TMatrixT.cxx:1374
 TMatrixT.cxx:1375
 TMatrixT.cxx:1376
 TMatrixT.cxx:1377
 TMatrixT.cxx:1378
 TMatrixT.cxx:1379
 TMatrixT.cxx:1380
 TMatrixT.cxx:1381
 TMatrixT.cxx:1382
 TMatrixT.cxx:1383
 TMatrixT.cxx:1384
 TMatrixT.cxx:1385
 TMatrixT.cxx:1386
 TMatrixT.cxx:1387
 TMatrixT.cxx:1388
 TMatrixT.cxx:1389
 TMatrixT.cxx:1390
 TMatrixT.cxx:1391
 TMatrixT.cxx:1392
 TMatrixT.cxx:1393
 TMatrixT.cxx:1394
 TMatrixT.cxx:1395
 TMatrixT.cxx:1396
 TMatrixT.cxx:1397
 TMatrixT.cxx:1398
 TMatrixT.cxx:1399
 TMatrixT.cxx:1400
 TMatrixT.cxx:1401
 TMatrixT.cxx:1402
 TMatrixT.cxx:1403
 TMatrixT.cxx:1404
 TMatrixT.cxx:1405
 TMatrixT.cxx:1406
 TMatrixT.cxx:1407
 TMatrixT.cxx:1408
 TMatrixT.cxx:1409
 TMatrixT.cxx:1410
 TMatrixT.cxx:1411
 TMatrixT.cxx:1412
 TMatrixT.cxx:1413
 TMatrixT.cxx:1414
 TMatrixT.cxx:1415
 TMatrixT.cxx:1416
 TMatrixT.cxx:1417
 TMatrixT.cxx:1418
 TMatrixT.cxx:1419
 TMatrixT.cxx:1420
 TMatrixT.cxx:1421
 TMatrixT.cxx:1422
 TMatrixT.cxx:1423
 TMatrixT.cxx:1424
 TMatrixT.cxx:1425
 TMatrixT.cxx:1426
 TMatrixT.cxx:1427
 TMatrixT.cxx:1428
 TMatrixT.cxx:1429
 TMatrixT.cxx:1430
 TMatrixT.cxx:1431
 TMatrixT.cxx:1432
 TMatrixT.cxx:1433
 TMatrixT.cxx:1434
 TMatrixT.cxx:1435
 TMatrixT.cxx:1436
 TMatrixT.cxx:1437
 TMatrixT.cxx:1438
 TMatrixT.cxx:1439
 TMatrixT.cxx:1440
 TMatrixT.cxx:1441
 TMatrixT.cxx:1442
 TMatrixT.cxx:1443
 TMatrixT.cxx:1444
 TMatrixT.cxx:1445
 TMatrixT.cxx:1446
 TMatrixT.cxx:1447
 TMatrixT.cxx:1448
 TMatrixT.cxx:1449
 TMatrixT.cxx:1450
 TMatrixT.cxx:1451
 TMatrixT.cxx:1452
 TMatrixT.cxx:1453
 TMatrixT.cxx:1454
 TMatrixT.cxx:1455
 TMatrixT.cxx:1456
 TMatrixT.cxx:1457
 TMatrixT.cxx:1458
 TMatrixT.cxx:1459
 TMatrixT.cxx:1460
 TMatrixT.cxx:1461
 TMatrixT.cxx:1462
 TMatrixT.cxx:1463
 TMatrixT.cxx:1464
 TMatrixT.cxx:1465
 TMatrixT.cxx:1466
 TMatrixT.cxx:1467
 TMatrixT.cxx:1468
 TMatrixT.cxx:1469
 TMatrixT.cxx:1470
 TMatrixT.cxx:1471
 TMatrixT.cxx:1472
 TMatrixT.cxx:1473
 TMatrixT.cxx:1474
 TMatrixT.cxx:1475
 TMatrixT.cxx:1476
 TMatrixT.cxx:1477
 TMatrixT.cxx:1478
 TMatrixT.cxx:1479
 TMatrixT.cxx:1480
 TMatrixT.cxx:1481
 TMatrixT.cxx:1482
 TMatrixT.cxx:1483
 TMatrixT.cxx:1484
 TMatrixT.cxx:1485
 TMatrixT.cxx:1486
 TMatrixT.cxx:1487
 TMatrixT.cxx:1488
 TMatrixT.cxx:1489
 TMatrixT.cxx:1490
 TMatrixT.cxx:1491
 TMatrixT.cxx:1492
 TMatrixT.cxx:1493
 TMatrixT.cxx:1494
 TMatrixT.cxx:1495
 TMatrixT.cxx:1496
 TMatrixT.cxx:1497
 TMatrixT.cxx:1498
 TMatrixT.cxx:1499
 TMatrixT.cxx:1500
 TMatrixT.cxx:1501
 TMatrixT.cxx:1502
 TMatrixT.cxx:1503
 TMatrixT.cxx:1504
 TMatrixT.cxx:1505
 TMatrixT.cxx:1506
 TMatrixT.cxx:1507
 TMatrixT.cxx:1508
 TMatrixT.cxx:1509
 TMatrixT.cxx:1510
 TMatrixT.cxx:1511
 TMatrixT.cxx:1512
 TMatrixT.cxx:1513
 TMatrixT.cxx:1514
 TMatrixT.cxx:1515
 TMatrixT.cxx:1516
 TMatrixT.cxx:1517
 TMatrixT.cxx:1518
 TMatrixT.cxx:1519
 TMatrixT.cxx:1520
 TMatrixT.cxx:1521
 TMatrixT.cxx:1522
 TMatrixT.cxx:1523
 TMatrixT.cxx:1524
 TMatrixT.cxx:1525
 TMatrixT.cxx:1526
 TMatrixT.cxx:1527
 TMatrixT.cxx:1528
 TMatrixT.cxx:1529
 TMatrixT.cxx:1530
 TMatrixT.cxx:1531
 TMatrixT.cxx:1532
 TMatrixT.cxx:1533
 TMatrixT.cxx:1534
 TMatrixT.cxx:1535
 TMatrixT.cxx:1536
 TMatrixT.cxx:1537
 TMatrixT.cxx:1538
 TMatrixT.cxx:1539
 TMatrixT.cxx:1540
 TMatrixT.cxx:1541
 TMatrixT.cxx:1542
 TMatrixT.cxx:1543
 TMatrixT.cxx:1544
 TMatrixT.cxx:1545
 TMatrixT.cxx:1546
 TMatrixT.cxx:1547
 TMatrixT.cxx:1548
 TMatrixT.cxx:1549
 TMatrixT.cxx:1550
 TMatrixT.cxx:1551
 TMatrixT.cxx:1552
 TMatrixT.cxx:1553
 TMatrixT.cxx:1554
 TMatrixT.cxx:1555
 TMatrixT.cxx:1556
 TMatrixT.cxx:1557
 TMatrixT.cxx:1558
 TMatrixT.cxx:1559
 TMatrixT.cxx:1560
 TMatrixT.cxx:1561
 TMatrixT.cxx:1562
 TMatrixT.cxx:1563
 TMatrixT.cxx:1564
 TMatrixT.cxx:1565
 TMatrixT.cxx:1566
 TMatrixT.cxx:1567
 TMatrixT.cxx:1568
 TMatrixT.cxx:1569
 TMatrixT.cxx:1570
 TMatrixT.cxx:1571
 TMatrixT.cxx:1572
 TMatrixT.cxx:1573
 TMatrixT.cxx:1574
 TMatrixT.cxx:1575
 TMatrixT.cxx:1576
 TMatrixT.cxx:1577
 TMatrixT.cxx:1578
 TMatrixT.cxx:1579
 TMatrixT.cxx:1580
 TMatrixT.cxx:1581
 TMatrixT.cxx:1582
 TMatrixT.cxx:1583
 TMatrixT.cxx:1584
 TMatrixT.cxx:1585
 TMatrixT.cxx:1586
 TMatrixT.cxx:1587
 TMatrixT.cxx:1588
 TMatrixT.cxx:1589
 TMatrixT.cxx:1590
 TMatrixT.cxx:1591
 TMatrixT.cxx:1592
 TMatrixT.cxx:1593
 TMatrixT.cxx:1594
 TMatrixT.cxx:1595
 TMatrixT.cxx:1596
 TMatrixT.cxx:1597
 TMatrixT.cxx:1598
 TMatrixT.cxx:1599
 TMatrixT.cxx:1600
 TMatrixT.cxx:1601
 TMatrixT.cxx:1602
 TMatrixT.cxx:1603
 TMatrixT.cxx:1604
 TMatrixT.cxx:1605
 TMatrixT.cxx:1606
 TMatrixT.cxx:1607
 TMatrixT.cxx:1608
 TMatrixT.cxx:1609
 TMatrixT.cxx:1610
 TMatrixT.cxx:1611
 TMatrixT.cxx:1612
 TMatrixT.cxx:1613
 TMatrixT.cxx:1614
 TMatrixT.cxx:1615
 TMatrixT.cxx:1616
 TMatrixT.cxx:1617
 TMatrixT.cxx:1618
 TMatrixT.cxx:1619
 TMatrixT.cxx:1620
 TMatrixT.cxx:1621
 TMatrixT.cxx:1622
 TMatrixT.cxx:1623
 TMatrixT.cxx:1624
 TMatrixT.cxx:1625
 TMatrixT.cxx:1626
 TMatrixT.cxx:1627
 TMatrixT.cxx:1628
 TMatrixT.cxx:1629
 TMatrixT.cxx:1630
 TMatrixT.cxx:1631
 TMatrixT.cxx:1632
 TMatrixT.cxx:1633
 TMatrixT.cxx:1634
 TMatrixT.cxx:1635
 TMatrixT.cxx:1636
 TMatrixT.cxx:1637
 TMatrixT.cxx:1638
 TMatrixT.cxx:1639
 TMatrixT.cxx:1640
 TMatrixT.cxx:1641
 TMatrixT.cxx:1642
 TMatrixT.cxx:1643
 TMatrixT.cxx:1644
 TMatrixT.cxx:1645
 TMatrixT.cxx:1646
 TMatrixT.cxx:1647
 TMatrixT.cxx:1648
 TMatrixT.cxx:1649
 TMatrixT.cxx:1650
 TMatrixT.cxx:1651
 TMatrixT.cxx:1652
 TMatrixT.cxx:1653
 TMatrixT.cxx:1654
 TMatrixT.cxx:1655
 TMatrixT.cxx:1656
 TMatrixT.cxx:1657
 TMatrixT.cxx:1658
 TMatrixT.cxx:1659
 TMatrixT.cxx:1660
 TMatrixT.cxx:1661
 TMatrixT.cxx:1662
 TMatrixT.cxx:1663
 TMatrixT.cxx:1664
 TMatrixT.cxx:1665
 TMatrixT.cxx:1666
 TMatrixT.cxx:1667
 TMatrixT.cxx:1668
 TMatrixT.cxx:1669
 TMatrixT.cxx:1670
 TMatrixT.cxx:1671
 TMatrixT.cxx:1672
 TMatrixT.cxx:1673
 TMatrixT.cxx:1674
 TMatrixT.cxx:1675
 TMatrixT.cxx:1676
 TMatrixT.cxx:1677
 TMatrixT.cxx:1678
 TMatrixT.cxx:1679
 TMatrixT.cxx:1680
 TMatrixT.cxx:1681
 TMatrixT.cxx:1682
 TMatrixT.cxx:1683
 TMatrixT.cxx:1684
 TMatrixT.cxx:1685
 TMatrixT.cxx:1686
 TMatrixT.cxx:1687
 TMatrixT.cxx:1688
 TMatrixT.cxx:1689
 TMatrixT.cxx:1690
 TMatrixT.cxx:1691
 TMatrixT.cxx:1692
 TMatrixT.cxx:1693
 TMatrixT.cxx:1694
 TMatrixT.cxx:1695
 TMatrixT.cxx:1696
 TMatrixT.cxx:1697
 TMatrixT.cxx:1698
 TMatrixT.cxx:1699
 TMatrixT.cxx:1700
 TMatrixT.cxx:1701
 TMatrixT.cxx:1702
 TMatrixT.cxx:1703
 TMatrixT.cxx:1704
 TMatrixT.cxx:1705
 TMatrixT.cxx:1706
 TMatrixT.cxx:1707
 TMatrixT.cxx:1708
 TMatrixT.cxx:1709
 TMatrixT.cxx:1710
 TMatrixT.cxx:1711
 TMatrixT.cxx:1712
 TMatrixT.cxx:1713
 TMatrixT.cxx:1714
 TMatrixT.cxx:1715
 TMatrixT.cxx:1716
 TMatrixT.cxx:1717
 TMatrixT.cxx:1718
 TMatrixT.cxx:1719
 TMatrixT.cxx:1720
 TMatrixT.cxx:1721
 TMatrixT.cxx:1722
 TMatrixT.cxx:1723
 TMatrixT.cxx:1724
 TMatrixT.cxx:1725
 TMatrixT.cxx:1726
 TMatrixT.cxx:1727
 TMatrixT.cxx:1728
 TMatrixT.cxx:1729
 TMatrixT.cxx:1730
 TMatrixT.cxx:1731
 TMatrixT.cxx:1732
 TMatrixT.cxx:1733
 TMatrixT.cxx:1734
 TMatrixT.cxx:1735
 TMatrixT.cxx:1736
 TMatrixT.cxx:1737
 TMatrixT.cxx:1738
 TMatrixT.cxx:1739
 TMatrixT.cxx:1740
 TMatrixT.cxx:1741
 TMatrixT.cxx:1742
 TMatrixT.cxx:1743
 TMatrixT.cxx:1744
 TMatrixT.cxx:1745
 TMatrixT.cxx:1746
 TMatrixT.cxx:1747
 TMatrixT.cxx:1748
 TMatrixT.cxx:1749
 TMatrixT.cxx:1750
 TMatrixT.cxx:1751
 TMatrixT.cxx:1752
 TMatrixT.cxx:1753
 TMatrixT.cxx:1754
 TMatrixT.cxx:1755
 TMatrixT.cxx:1756
 TMatrixT.cxx:1757
 TMatrixT.cxx:1758
 TMatrixT.cxx:1759
 TMatrixT.cxx:1760
 TMatrixT.cxx:1761
 TMatrixT.cxx:1762
 TMatrixT.cxx:1763
 TMatrixT.cxx:1764
 TMatrixT.cxx:1765
 TMatrixT.cxx:1766
 TMatrixT.cxx:1767
 TMatrixT.cxx:1768
 TMatrixT.cxx:1769
 TMatrixT.cxx:1770
 TMatrixT.cxx:1771
 TMatrixT.cxx:1772
 TMatrixT.cxx:1773
 TMatrixT.cxx:1774
 TMatrixT.cxx:1775
 TMatrixT.cxx:1776
 TMatrixT.cxx:1777
 TMatrixT.cxx:1778
 TMatrixT.cxx:1779
 TMatrixT.cxx:1780
 TMatrixT.cxx:1781
 TMatrixT.cxx:1782
 TMatrixT.cxx:1783
 TMatrixT.cxx:1784
 TMatrixT.cxx:1785
 TMatrixT.cxx:1786
 TMatrixT.cxx:1787
 TMatrixT.cxx:1788
 TMatrixT.cxx:1789
 TMatrixT.cxx:1790
 TMatrixT.cxx:1791
 TMatrixT.cxx:1792
 TMatrixT.cxx:1793
 TMatrixT.cxx:1794
 TMatrixT.cxx:1795
 TMatrixT.cxx:1796
 TMatrixT.cxx:1797
 TMatrixT.cxx:1798
 TMatrixT.cxx:1799
 TMatrixT.cxx:1800
 TMatrixT.cxx:1801
 TMatrixT.cxx:1802
 TMatrixT.cxx:1803
 TMatrixT.cxx:1804
 TMatrixT.cxx:1805
 TMatrixT.cxx:1806
 TMatrixT.cxx:1807
 TMatrixT.cxx:1808
 TMatrixT.cxx:1809
 TMatrixT.cxx:1810
 TMatrixT.cxx:1811
 TMatrixT.cxx:1812
 TMatrixT.cxx:1813
 TMatrixT.cxx:1814
 TMatrixT.cxx:1815
 TMatrixT.cxx:1816
 TMatrixT.cxx:1817
 TMatrixT.cxx:1818
 TMatrixT.cxx:1819
 TMatrixT.cxx:1820
 TMatrixT.cxx:1821
 TMatrixT.cxx:1822
 TMatrixT.cxx:1823
 TMatrixT.cxx:1824
 TMatrixT.cxx:1825
 TMatrixT.cxx:1826
 TMatrixT.cxx:1827
 TMatrixT.cxx:1828
 TMatrixT.cxx:1829
 TMatrixT.cxx:1830
 TMatrixT.cxx:1831
 TMatrixT.cxx:1832
 TMatrixT.cxx:1833
 TMatrixT.cxx:1834
 TMatrixT.cxx:1835
 TMatrixT.cxx:1836
 TMatrixT.cxx:1837
 TMatrixT.cxx:1838
 TMatrixT.cxx:1839
 TMatrixT.cxx:1840
 TMatrixT.cxx:1841
 TMatrixT.cxx:1842
 TMatrixT.cxx:1843
 TMatrixT.cxx:1844
 TMatrixT.cxx:1845
 TMatrixT.cxx:1846
 TMatrixT.cxx:1847
 TMatrixT.cxx:1848
 TMatrixT.cxx:1849
 TMatrixT.cxx:1850
 TMatrixT.cxx:1851
 TMatrixT.cxx:1852
 TMatrixT.cxx:1853
 TMatrixT.cxx:1854
 TMatrixT.cxx:1855
 TMatrixT.cxx:1856
 TMatrixT.cxx:1857
 TMatrixT.cxx:1858
 TMatrixT.cxx:1859
 TMatrixT.cxx:1860
 TMatrixT.cxx:1861
 TMatrixT.cxx:1862
 TMatrixT.cxx:1863
 TMatrixT.cxx:1864
 TMatrixT.cxx:1865
 TMatrixT.cxx:1866
 TMatrixT.cxx:1867
 TMatrixT.cxx:1868
 TMatrixT.cxx:1869
 TMatrixT.cxx:1870
 TMatrixT.cxx:1871
 TMatrixT.cxx:1872
 TMatrixT.cxx:1873
 TMatrixT.cxx:1874
 TMatrixT.cxx:1875
 TMatrixT.cxx:1876
 TMatrixT.cxx:1877
 TMatrixT.cxx:1878
 TMatrixT.cxx:1879
 TMatrixT.cxx:1880
 TMatrixT.cxx:1881
 TMatrixT.cxx:1882
 TMatrixT.cxx:1883
 TMatrixT.cxx:1884
 TMatrixT.cxx:1885
 TMatrixT.cxx:1886
 TMatrixT.cxx:1887
 TMatrixT.cxx:1888
 TMatrixT.cxx:1889
 TMatrixT.cxx:1890
 TMatrixT.cxx:1891
 TMatrixT.cxx:1892
 TMatrixT.cxx:1893
 TMatrixT.cxx:1894
 TMatrixT.cxx:1895
 TMatrixT.cxx:1896
 TMatrixT.cxx:1897
 TMatrixT.cxx:1898
 TMatrixT.cxx:1899
 TMatrixT.cxx:1900
 TMatrixT.cxx:1901
 TMatrixT.cxx:1902
 TMatrixT.cxx:1903
 TMatrixT.cxx:1904
 TMatrixT.cxx:1905
 TMatrixT.cxx:1906
 TMatrixT.cxx:1907
 TMatrixT.cxx:1908
 TMatrixT.cxx:1909
 TMatrixT.cxx:1910
 TMatrixT.cxx:1911
 TMatrixT.cxx:1912
 TMatrixT.cxx:1913
 TMatrixT.cxx:1914
 TMatrixT.cxx:1915
 TMatrixT.cxx:1916
 TMatrixT.cxx:1917
 TMatrixT.cxx:1918
 TMatrixT.cxx:1919
 TMatrixT.cxx:1920
 TMatrixT.cxx:1921
 TMatrixT.cxx:1922
 TMatrixT.cxx:1923
 TMatrixT.cxx:1924
 TMatrixT.cxx:1925
 TMatrixT.cxx:1926
 TMatrixT.cxx:1927
 TMatrixT.cxx:1928
 TMatrixT.cxx:1929
 TMatrixT.cxx:1930
 TMatrixT.cxx:1931
 TMatrixT.cxx:1932
 TMatrixT.cxx:1933
 TMatrixT.cxx:1934
 TMatrixT.cxx:1935
 TMatrixT.cxx:1936
 TMatrixT.cxx:1937
 TMatrixT.cxx:1938
 TMatrixT.cxx:1939
 TMatrixT.cxx:1940
 TMatrixT.cxx:1941
 TMatrixT.cxx:1942
 TMatrixT.cxx:1943
 TMatrixT.cxx:1944
 TMatrixT.cxx:1945
 TMatrixT.cxx:1946
 TMatrixT.cxx:1947
 TMatrixT.cxx:1948
 TMatrixT.cxx:1949
 TMatrixT.cxx:1950
 TMatrixT.cxx:1951
 TMatrixT.cxx:1952
 TMatrixT.cxx:1953
 TMatrixT.cxx:1954
 TMatrixT.cxx:1955
 TMatrixT.cxx:1956
 TMatrixT.cxx:1957
 TMatrixT.cxx:1958
 TMatrixT.cxx:1959
 TMatrixT.cxx:1960
 TMatrixT.cxx:1961
 TMatrixT.cxx:1962
 TMatrixT.cxx:1963
 TMatrixT.cxx:1964
 TMatrixT.cxx:1965
 TMatrixT.cxx:1966
 TMatrixT.cxx:1967
 TMatrixT.cxx:1968
 TMatrixT.cxx:1969
 TMatrixT.cxx:1970
 TMatrixT.cxx:1971
 TMatrixT.cxx:1972
 TMatrixT.cxx:1973
 TMatrixT.cxx:1974
 TMatrixT.cxx:1975
 TMatrixT.cxx:1976
 TMatrixT.cxx:1977
 TMatrixT.cxx:1978
 TMatrixT.cxx:1979
 TMatrixT.cxx:1980
 TMatrixT.cxx:1981
 TMatrixT.cxx:1982
 TMatrixT.cxx:1983
 TMatrixT.cxx:1984
 TMatrixT.cxx:1985
 TMatrixT.cxx:1986
 TMatrixT.cxx:1987
 TMatrixT.cxx:1988
 TMatrixT.cxx:1989
 TMatrixT.cxx:1990
 TMatrixT.cxx:1991
 TMatrixT.cxx:1992
 TMatrixT.cxx:1993
 TMatrixT.cxx:1994
 TMatrixT.cxx:1995
 TMatrixT.cxx:1996
 TMatrixT.cxx:1997
 TMatrixT.cxx:1998
 TMatrixT.cxx:1999
 TMatrixT.cxx:2000
 TMatrixT.cxx:2001
 TMatrixT.cxx:2002
 TMatrixT.cxx:2003
 TMatrixT.cxx:2004
 TMatrixT.cxx:2005
 TMatrixT.cxx:2006
 TMatrixT.cxx:2007
 TMatrixT.cxx:2008
 TMatrixT.cxx:2009
 TMatrixT.cxx:2010
 TMatrixT.cxx:2011
 TMatrixT.cxx:2012
 TMatrixT.cxx:2013
 TMatrixT.cxx:2014
 TMatrixT.cxx:2015
 TMatrixT.cxx:2016
 TMatrixT.cxx:2017
 TMatrixT.cxx:2018
 TMatrixT.cxx:2019
 TMatrixT.cxx:2020
 TMatrixT.cxx:2021
 TMatrixT.cxx:2022
 TMatrixT.cxx:2023
 TMatrixT.cxx:2024
 TMatrixT.cxx:2025
 TMatrixT.cxx:2026
 TMatrixT.cxx:2027
 TMatrixT.cxx:2028
 TMatrixT.cxx:2029
 TMatrixT.cxx:2030
 TMatrixT.cxx:2031
 TMatrixT.cxx:2032
 TMatrixT.cxx:2033
 TMatrixT.cxx:2034
 TMatrixT.cxx:2035
 TMatrixT.cxx:2036
 TMatrixT.cxx:2037
 TMatrixT.cxx:2038
 TMatrixT.cxx:2039
 TMatrixT.cxx:2040
 TMatrixT.cxx:2041
 TMatrixT.cxx:2042
 TMatrixT.cxx:2043
 TMatrixT.cxx:2044
 TMatrixT.cxx:2045
 TMatrixT.cxx:2046
 TMatrixT.cxx:2047
 TMatrixT.cxx:2048
 TMatrixT.cxx:2049
 TMatrixT.cxx:2050
 TMatrixT.cxx:2051
 TMatrixT.cxx:2052
 TMatrixT.cxx:2053
 TMatrixT.cxx:2054
 TMatrixT.cxx:2055
 TMatrixT.cxx:2056
 TMatrixT.cxx:2057
 TMatrixT.cxx:2058
 TMatrixT.cxx:2059
 TMatrixT.cxx:2060
 TMatrixT.cxx:2061
 TMatrixT.cxx:2062
 TMatrixT.cxx:2063
 TMatrixT.cxx:2064
 TMatrixT.cxx:2065
 TMatrixT.cxx:2066
 TMatrixT.cxx:2067
 TMatrixT.cxx:2068
 TMatrixT.cxx:2069
 TMatrixT.cxx:2070
 TMatrixT.cxx:2071
 TMatrixT.cxx:2072
 TMatrixT.cxx:2073
 TMatrixT.cxx:2074
 TMatrixT.cxx:2075
 TMatrixT.cxx:2076
 TMatrixT.cxx:2077
 TMatrixT.cxx:2078
 TMatrixT.cxx:2079
 TMatrixT.cxx:2080
 TMatrixT.cxx:2081
 TMatrixT.cxx:2082
 TMatrixT.cxx:2083
 TMatrixT.cxx:2084
 TMatrixT.cxx:2085
 TMatrixT.cxx:2086
 TMatrixT.cxx:2087
 TMatrixT.cxx:2088
 TMatrixT.cxx:2089
 TMatrixT.cxx:2090
 TMatrixT.cxx:2091
 TMatrixT.cxx:2092
 TMatrixT.cxx:2093
 TMatrixT.cxx:2094
 TMatrixT.cxx:2095
 TMatrixT.cxx:2096
 TMatrixT.cxx:2097
 TMatrixT.cxx:2098
 TMatrixT.cxx:2099
 TMatrixT.cxx:2100
 TMatrixT.cxx:2101
 TMatrixT.cxx:2102
 TMatrixT.cxx:2103
 TMatrixT.cxx:2104
 TMatrixT.cxx:2105
 TMatrixT.cxx:2106
 TMatrixT.cxx:2107
 TMatrixT.cxx:2108
 TMatrixT.cxx:2109
 TMatrixT.cxx:2110
 TMatrixT.cxx:2111
 TMatrixT.cxx:2112
 TMatrixT.cxx:2113
 TMatrixT.cxx:2114
 TMatrixT.cxx:2115
 TMatrixT.cxx:2116
 TMatrixT.cxx:2117
 TMatrixT.cxx:2118
 TMatrixT.cxx:2119
 TMatrixT.cxx:2120
 TMatrixT.cxx:2121
 TMatrixT.cxx:2122
 TMatrixT.cxx:2123
 TMatrixT.cxx:2124
 TMatrixT.cxx:2125
 TMatrixT.cxx:2126
 TMatrixT.cxx:2127
 TMatrixT.cxx:2128
 TMatrixT.cxx:2129
 TMatrixT.cxx:2130
 TMatrixT.cxx:2131
 TMatrixT.cxx:2132
 TMatrixT.cxx:2133
 TMatrixT.cxx:2134
 TMatrixT.cxx:2135
 TMatrixT.cxx:2136
 TMatrixT.cxx:2137
 TMatrixT.cxx:2138
 TMatrixT.cxx:2139
 TMatrixT.cxx:2140
 TMatrixT.cxx:2141
 TMatrixT.cxx:2142
 TMatrixT.cxx:2143
 TMatrixT.cxx:2144
 TMatrixT.cxx:2145
 TMatrixT.cxx:2146
 TMatrixT.cxx:2147
 TMatrixT.cxx:2148
 TMatrixT.cxx:2149
 TMatrixT.cxx:2150
 TMatrixT.cxx:2151
 TMatrixT.cxx:2152
 TMatrixT.cxx:2153
 TMatrixT.cxx:2154
 TMatrixT.cxx:2155
 TMatrixT.cxx:2156
 TMatrixT.cxx:2157
 TMatrixT.cxx:2158
 TMatrixT.cxx:2159
 TMatrixT.cxx:2160
 TMatrixT.cxx:2161
 TMatrixT.cxx:2162
 TMatrixT.cxx:2163
 TMatrixT.cxx:2164
 TMatrixT.cxx:2165
 TMatrixT.cxx:2166
 TMatrixT.cxx:2167
 TMatrixT.cxx:2168
 TMatrixT.cxx:2169
 TMatrixT.cxx:2170
 TMatrixT.cxx:2171
 TMatrixT.cxx:2172
 TMatrixT.cxx:2173
 TMatrixT.cxx:2174
 TMatrixT.cxx:2175
 TMatrixT.cxx:2176
 TMatrixT.cxx:2177
 TMatrixT.cxx:2178
 TMatrixT.cxx:2179
 TMatrixT.cxx:2180
 TMatrixT.cxx:2181
 TMatrixT.cxx:2182
 TMatrixT.cxx:2183
 TMatrixT.cxx:2184
 TMatrixT.cxx:2185
 TMatrixT.cxx:2186
 TMatrixT.cxx:2187
 TMatrixT.cxx:2188
 TMatrixT.cxx:2189
 TMatrixT.cxx:2190
 TMatrixT.cxx:2191
 TMatrixT.cxx:2192
 TMatrixT.cxx:2193
 TMatrixT.cxx:2194
 TMatrixT.cxx:2195
 TMatrixT.cxx:2196
 TMatrixT.cxx:2197
 TMatrixT.cxx:2198
 TMatrixT.cxx:2199
 TMatrixT.cxx:2200
 TMatrixT.cxx:2201
 TMatrixT.cxx:2202
 TMatrixT.cxx:2203
 TMatrixT.cxx:2204
 TMatrixT.cxx:2205
 TMatrixT.cxx:2206
 TMatrixT.cxx:2207
 TMatrixT.cxx:2208
 TMatrixT.cxx:2209
 TMatrixT.cxx:2210
 TMatrixT.cxx:2211
 TMatrixT.cxx:2212
 TMatrixT.cxx:2213
 TMatrixT.cxx:2214
 TMatrixT.cxx:2215
 TMatrixT.cxx:2216
 TMatrixT.cxx:2217
 TMatrixT.cxx:2218
 TMatrixT.cxx:2219
 TMatrixT.cxx:2220
 TMatrixT.cxx:2221
 TMatrixT.cxx:2222
 TMatrixT.cxx:2223
 TMatrixT.cxx:2224
 TMatrixT.cxx:2225
 TMatrixT.cxx:2226
 TMatrixT.cxx:2227
 TMatrixT.cxx:2228
 TMatrixT.cxx:2229
 TMatrixT.cxx:2230
 TMatrixT.cxx:2231
 TMatrixT.cxx:2232
 TMatrixT.cxx:2233
 TMatrixT.cxx:2234
 TMatrixT.cxx:2235
 TMatrixT.cxx:2236
 TMatrixT.cxx:2237
 TMatrixT.cxx:2238
 TMatrixT.cxx:2239
 TMatrixT.cxx:2240
 TMatrixT.cxx:2241
 TMatrixT.cxx:2242
 TMatrixT.cxx:2243
 TMatrixT.cxx:2244
 TMatrixT.cxx:2245
 TMatrixT.cxx:2246
 TMatrixT.cxx:2247
 TMatrixT.cxx:2248
 TMatrixT.cxx:2249
 TMatrixT.cxx:2250
 TMatrixT.cxx:2251
 TMatrixT.cxx:2252
 TMatrixT.cxx:2253
 TMatrixT.cxx:2254
 TMatrixT.cxx:2255
 TMatrixT.cxx:2256
 TMatrixT.cxx:2257
 TMatrixT.cxx:2258
 TMatrixT.cxx:2259
 TMatrixT.cxx:2260
 TMatrixT.cxx:2261
 TMatrixT.cxx:2262
 TMatrixT.cxx:2263
 TMatrixT.cxx:2264
 TMatrixT.cxx:2265
 TMatrixT.cxx:2266
 TMatrixT.cxx:2267
 TMatrixT.cxx:2268
 TMatrixT.cxx:2269
 TMatrixT.cxx:2270
 TMatrixT.cxx:2271
 TMatrixT.cxx:2272
 TMatrixT.cxx:2273
 TMatrixT.cxx:2274
 TMatrixT.cxx:2275
 TMatrixT.cxx:2276
 TMatrixT.cxx:2277
 TMatrixT.cxx:2278
 TMatrixT.cxx:2279
 TMatrixT.cxx:2280
 TMatrixT.cxx:2281
 TMatrixT.cxx:2282
 TMatrixT.cxx:2283
 TMatrixT.cxx:2284
 TMatrixT.cxx:2285
 TMatrixT.cxx:2286
 TMatrixT.cxx:2287
 TMatrixT.cxx:2288
 TMatrixT.cxx:2289
 TMatrixT.cxx:2290
 TMatrixT.cxx:2291
 TMatrixT.cxx:2292
 TMatrixT.cxx:2293
 TMatrixT.cxx:2294
 TMatrixT.cxx:2295
 TMatrixT.cxx:2296
 TMatrixT.cxx:2297
 TMatrixT.cxx:2298
 TMatrixT.cxx:2299
 TMatrixT.cxx:2300
 TMatrixT.cxx:2301
 TMatrixT.cxx:2302
 TMatrixT.cxx:2303
 TMatrixT.cxx:2304
 TMatrixT.cxx:2305
 TMatrixT.cxx:2306
 TMatrixT.cxx:2307
 TMatrixT.cxx:2308
 TMatrixT.cxx:2309
 TMatrixT.cxx:2310
 TMatrixT.cxx:2311
 TMatrixT.cxx:2312
 TMatrixT.cxx:2313
 TMatrixT.cxx:2314
 TMatrixT.cxx:2315
 TMatrixT.cxx:2316
 TMatrixT.cxx:2317
 TMatrixT.cxx:2318
 TMatrixT.cxx:2319
 TMatrixT.cxx:2320
 TMatrixT.cxx:2321
 TMatrixT.cxx:2322
 TMatrixT.cxx:2323
 TMatrixT.cxx:2324
 TMatrixT.cxx:2325
 TMatrixT.cxx:2326
 TMatrixT.cxx:2327
 TMatrixT.cxx:2328
 TMatrixT.cxx:2329
 TMatrixT.cxx:2330
 TMatrixT.cxx:2331
 TMatrixT.cxx:2332
 TMatrixT.cxx:2333
 TMatrixT.cxx:2334
 TMatrixT.cxx:2335
 TMatrixT.cxx:2336
 TMatrixT.cxx:2337
 TMatrixT.cxx:2338
 TMatrixT.cxx:2339
 TMatrixT.cxx:2340
 TMatrixT.cxx:2341
 TMatrixT.cxx:2342
 TMatrixT.cxx:2343
 TMatrixT.cxx:2344
 TMatrixT.cxx:2345
 TMatrixT.cxx:2346
 TMatrixT.cxx:2347
 TMatrixT.cxx:2348
 TMatrixT.cxx:2349
 TMatrixT.cxx:2350
 TMatrixT.cxx:2351
 TMatrixT.cxx:2352
 TMatrixT.cxx:2353
 TMatrixT.cxx:2354
 TMatrixT.cxx:2355
 TMatrixT.cxx:2356
 TMatrixT.cxx:2357
 TMatrixT.cxx:2358
 TMatrixT.cxx:2359
 TMatrixT.cxx:2360
 TMatrixT.cxx:2361
 TMatrixT.cxx:2362
 TMatrixT.cxx:2363
 TMatrixT.cxx:2364
 TMatrixT.cxx:2365
 TMatrixT.cxx:2366
 TMatrixT.cxx:2367
 TMatrixT.cxx:2368
 TMatrixT.cxx:2369
 TMatrixT.cxx:2370
 TMatrixT.cxx:2371
 TMatrixT.cxx:2372
 TMatrixT.cxx:2373
 TMatrixT.cxx:2374
 TMatrixT.cxx:2375
 TMatrixT.cxx:2376
 TMatrixT.cxx:2377
 TMatrixT.cxx:2378
 TMatrixT.cxx:2379
 TMatrixT.cxx:2380
 TMatrixT.cxx:2381
 TMatrixT.cxx:2382
 TMatrixT.cxx:2383
 TMatrixT.cxx:2384
 TMatrixT.cxx:2385
 TMatrixT.cxx:2386
 TMatrixT.cxx:2387
 TMatrixT.cxx:2388
 TMatrixT.cxx:2389
 TMatrixT.cxx:2390
 TMatrixT.cxx:2391
 TMatrixT.cxx:2392
 TMatrixT.cxx:2393
 TMatrixT.cxx:2394
 TMatrixT.cxx:2395
 TMatrixT.cxx:2396
 TMatrixT.cxx:2397
 TMatrixT.cxx:2398
 TMatrixT.cxx:2399
 TMatrixT.cxx:2400
 TMatrixT.cxx:2401
 TMatrixT.cxx:2402
 TMatrixT.cxx:2403
 TMatrixT.cxx:2404
 TMatrixT.cxx:2405
 TMatrixT.cxx:2406
 TMatrixT.cxx:2407
 TMatrixT.cxx:2408
 TMatrixT.cxx:2409
 TMatrixT.cxx:2410
 TMatrixT.cxx:2411
 TMatrixT.cxx:2412
 TMatrixT.cxx:2413
 TMatrixT.cxx:2414
 TMatrixT.cxx:2415
 TMatrixT.cxx:2416
 TMatrixT.cxx:2417
 TMatrixT.cxx:2418
 TMatrixT.cxx:2419
 TMatrixT.cxx:2420
 TMatrixT.cxx:2421
 TMatrixT.cxx:2422
 TMatrixT.cxx:2423
 TMatrixT.cxx:2424
 TMatrixT.cxx:2425
 TMatrixT.cxx:2426
 TMatrixT.cxx:2427
 TMatrixT.cxx:2428
 TMatrixT.cxx:2429
 TMatrixT.cxx:2430
 TMatrixT.cxx:2431
 TMatrixT.cxx:2432
 TMatrixT.cxx:2433
 TMatrixT.cxx:2434
 TMatrixT.cxx:2435
 TMatrixT.cxx:2436
 TMatrixT.cxx:2437
 TMatrixT.cxx:2438
 TMatrixT.cxx:2439
 TMatrixT.cxx:2440
 TMatrixT.cxx:2441
 TMatrixT.cxx:2442
 TMatrixT.cxx:2443
 TMatrixT.cxx:2444
 TMatrixT.cxx:2445
 TMatrixT.cxx:2446
 TMatrixT.cxx:2447
 TMatrixT.cxx:2448
 TMatrixT.cxx:2449
 TMatrixT.cxx:2450
 TMatrixT.cxx:2451
 TMatrixT.cxx:2452
 TMatrixT.cxx:2453
 TMatrixT.cxx:2454
 TMatrixT.cxx:2455
 TMatrixT.cxx:2456
 TMatrixT.cxx:2457
 TMatrixT.cxx:2458
 TMatrixT.cxx:2459
 TMatrixT.cxx:2460
 TMatrixT.cxx:2461
 TMatrixT.cxx:2462
 TMatrixT.cxx:2463
 TMatrixT.cxx:2464
 TMatrixT.cxx:2465
 TMatrixT.cxx:2466
 TMatrixT.cxx:2467
 TMatrixT.cxx:2468
 TMatrixT.cxx:2469
 TMatrixT.cxx:2470
 TMatrixT.cxx:2471
 TMatrixT.cxx:2472
 TMatrixT.cxx:2473
 TMatrixT.cxx:2474
 TMatrixT.cxx:2475
 TMatrixT.cxx:2476
 TMatrixT.cxx:2477
 TMatrixT.cxx:2478
 TMatrixT.cxx:2479
 TMatrixT.cxx:2480
 TMatrixT.cxx:2481
 TMatrixT.cxx:2482
 TMatrixT.cxx:2483
 TMatrixT.cxx:2484
 TMatrixT.cxx:2485
 TMatrixT.cxx:2486
 TMatrixT.cxx:2487
 TMatrixT.cxx:2488
 TMatrixT.cxx:2489
 TMatrixT.cxx:2490
 TMatrixT.cxx:2491
 TMatrixT.cxx:2492
 TMatrixT.cxx:2493
 TMatrixT.cxx:2494
 TMatrixT.cxx:2495
 TMatrixT.cxx:2496
 TMatrixT.cxx:2497
 TMatrixT.cxx:2498
 TMatrixT.cxx:2499
 TMatrixT.cxx:2500
 TMatrixT.cxx:2501
 TMatrixT.cxx:2502
 TMatrixT.cxx:2503
 TMatrixT.cxx:2504
 TMatrixT.cxx:2505
 TMatrixT.cxx:2506
 TMatrixT.cxx:2507
 TMatrixT.cxx:2508
 TMatrixT.cxx:2509
 TMatrixT.cxx:2510
 TMatrixT.cxx:2511
 TMatrixT.cxx:2512
 TMatrixT.cxx:2513
 TMatrixT.cxx:2514
 TMatrixT.cxx:2515
 TMatrixT.cxx:2516
 TMatrixT.cxx:2517
 TMatrixT.cxx:2518
 TMatrixT.cxx:2519
 TMatrixT.cxx:2520
 TMatrixT.cxx:2521
 TMatrixT.cxx:2522
 TMatrixT.cxx:2523
 TMatrixT.cxx:2524
 TMatrixT.cxx:2525
 TMatrixT.cxx:2526
 TMatrixT.cxx:2527
 TMatrixT.cxx:2528
 TMatrixT.cxx:2529
 TMatrixT.cxx:2530
 TMatrixT.cxx:2531
 TMatrixT.cxx:2532
 TMatrixT.cxx:2533
 TMatrixT.cxx:2534
 TMatrixT.cxx:2535
 TMatrixT.cxx:2536
 TMatrixT.cxx:2537
 TMatrixT.cxx:2538
 TMatrixT.cxx:2539
 TMatrixT.cxx:2540
 TMatrixT.cxx:2541
 TMatrixT.cxx:2542
 TMatrixT.cxx:2543
 TMatrixT.cxx:2544
 TMatrixT.cxx:2545
 TMatrixT.cxx:2546
 TMatrixT.cxx:2547
 TMatrixT.cxx:2548
 TMatrixT.cxx:2549
 TMatrixT.cxx:2550
 TMatrixT.cxx:2551
 TMatrixT.cxx:2552
 TMatrixT.cxx:2553
 TMatrixT.cxx:2554
 TMatrixT.cxx:2555
 TMatrixT.cxx:2556
 TMatrixT.cxx:2557
 TMatrixT.cxx:2558
 TMatrixT.cxx:2559
 TMatrixT.cxx:2560
 TMatrixT.cxx:2561
 TMatrixT.cxx:2562
 TMatrixT.cxx:2563
 TMatrixT.cxx:2564
 TMatrixT.cxx:2565
 TMatrixT.cxx:2566
 TMatrixT.cxx:2567
 TMatrixT.cxx:2568
 TMatrixT.cxx:2569
 TMatrixT.cxx:2570
 TMatrixT.cxx:2571
 TMatrixT.cxx:2572
 TMatrixT.cxx:2573
 TMatrixT.cxx:2574
 TMatrixT.cxx:2575
 TMatrixT.cxx:2576
 TMatrixT.cxx:2577
 TMatrixT.cxx:2578
 TMatrixT.cxx:2579
 TMatrixT.cxx:2580
 TMatrixT.cxx:2581
 TMatrixT.cxx:2582
 TMatrixT.cxx:2583
 TMatrixT.cxx:2584
 TMatrixT.cxx:2585
 TMatrixT.cxx:2586
 TMatrixT.cxx:2587
 TMatrixT.cxx:2588
 TMatrixT.cxx:2589
 TMatrixT.cxx:2590
 TMatrixT.cxx:2591
 TMatrixT.cxx:2592
 TMatrixT.cxx:2593
 TMatrixT.cxx:2594
 TMatrixT.cxx:2595
 TMatrixT.cxx:2596
 TMatrixT.cxx:2597
 TMatrixT.cxx:2598
 TMatrixT.cxx:2599
 TMatrixT.cxx:2600
 TMatrixT.cxx:2601
 TMatrixT.cxx:2602
 TMatrixT.cxx:2603
 TMatrixT.cxx:2604
 TMatrixT.cxx:2605
 TMatrixT.cxx:2606
 TMatrixT.cxx:2607
 TMatrixT.cxx:2608
 TMatrixT.cxx:2609
 TMatrixT.cxx:2610
 TMatrixT.cxx:2611
 TMatrixT.cxx:2612
 TMatrixT.cxx:2613
 TMatrixT.cxx:2614
 TMatrixT.cxx:2615
 TMatrixT.cxx:2616
 TMatrixT.cxx:2617
 TMatrixT.cxx:2618
 TMatrixT.cxx:2619
 TMatrixT.cxx:2620
 TMatrixT.cxx:2621
 TMatrixT.cxx:2622
 TMatrixT.cxx:2623
 TMatrixT.cxx:2624
 TMatrixT.cxx:2625
 TMatrixT.cxx:2626
 TMatrixT.cxx:2627
 TMatrixT.cxx:2628
 TMatrixT.cxx:2629
 TMatrixT.cxx:2630
 TMatrixT.cxx:2631
 TMatrixT.cxx:2632
 TMatrixT.cxx:2633
 TMatrixT.cxx:2634
 TMatrixT.cxx:2635
 TMatrixT.cxx:2636
 TMatrixT.cxx:2637
 TMatrixT.cxx:2638
 TMatrixT.cxx:2639
 TMatrixT.cxx:2640
 TMatrixT.cxx:2641
 TMatrixT.cxx:2642
 TMatrixT.cxx:2643
 TMatrixT.cxx:2644
 TMatrixT.cxx:2645
 TMatrixT.cxx:2646
 TMatrixT.cxx:2647
 TMatrixT.cxx:2648
 TMatrixT.cxx:2649
 TMatrixT.cxx:2650
 TMatrixT.cxx:2651
 TMatrixT.cxx:2652
 TMatrixT.cxx:2653
 TMatrixT.cxx:2654
 TMatrixT.cxx:2655
 TMatrixT.cxx:2656
 TMatrixT.cxx:2657
 TMatrixT.cxx:2658
 TMatrixT.cxx:2659
 TMatrixT.cxx:2660
 TMatrixT.cxx:2661
 TMatrixT.cxx:2662
 TMatrixT.cxx:2663
 TMatrixT.cxx:2664
 TMatrixT.cxx:2665
 TMatrixT.cxx:2666
 TMatrixT.cxx:2667
 TMatrixT.cxx:2668
 TMatrixT.cxx:2669
 TMatrixT.cxx:2670
 TMatrixT.cxx:2671
 TMatrixT.cxx:2672
 TMatrixT.cxx:2673
 TMatrixT.cxx:2674
 TMatrixT.cxx:2675
 TMatrixT.cxx:2676
 TMatrixT.cxx:2677
 TMatrixT.cxx:2678
 TMatrixT.cxx:2679
 TMatrixT.cxx:2680
 TMatrixT.cxx:2681
 TMatrixT.cxx:2682
 TMatrixT.cxx:2683
 TMatrixT.cxx:2684
 TMatrixT.cxx:2685
 TMatrixT.cxx:2686
 TMatrixT.cxx:2687
 TMatrixT.cxx:2688
 TMatrixT.cxx:2689
 TMatrixT.cxx:2690
 TMatrixT.cxx:2691
 TMatrixT.cxx:2692
 TMatrixT.cxx:2693
 TMatrixT.cxx:2694
 TMatrixT.cxx:2695
 TMatrixT.cxx:2696
 TMatrixT.cxx:2697
 TMatrixT.cxx:2698
 TMatrixT.cxx:2699
 TMatrixT.cxx:2700
 TMatrixT.cxx:2701
 TMatrixT.cxx:2702
 TMatrixT.cxx:2703
 TMatrixT.cxx:2704
 TMatrixT.cxx:2705
 TMatrixT.cxx:2706
 TMatrixT.cxx:2707
 TMatrixT.cxx:2708
 TMatrixT.cxx:2709
 TMatrixT.cxx:2710
 TMatrixT.cxx:2711
 TMatrixT.cxx:2712
 TMatrixT.cxx:2713
 TMatrixT.cxx:2714
 TMatrixT.cxx:2715
 TMatrixT.cxx:2716
 TMatrixT.cxx:2717
 TMatrixT.cxx:2718
 TMatrixT.cxx:2719
 TMatrixT.cxx:2720
 TMatrixT.cxx:2721
 TMatrixT.cxx:2722
 TMatrixT.cxx:2723
 TMatrixT.cxx:2724
 TMatrixT.cxx:2725
 TMatrixT.cxx:2726
 TMatrixT.cxx:2727
 TMatrixT.cxx:2728
 TMatrixT.cxx:2729
 TMatrixT.cxx:2730
 TMatrixT.cxx:2731
 TMatrixT.cxx:2732
 TMatrixT.cxx:2733
 TMatrixT.cxx:2734
 TMatrixT.cxx:2735
 TMatrixT.cxx:2736
 TMatrixT.cxx:2737
 TMatrixT.cxx:2738
 TMatrixT.cxx:2739
 TMatrixT.cxx:2740
 TMatrixT.cxx:2741
 TMatrixT.cxx:2742
 TMatrixT.cxx:2743
 TMatrixT.cxx:2744
 TMatrixT.cxx:2745
 TMatrixT.cxx:2746
 TMatrixT.cxx:2747
 TMatrixT.cxx:2748
 TMatrixT.cxx:2749
 TMatrixT.cxx:2750
 TMatrixT.cxx:2751
 TMatrixT.cxx:2752
 TMatrixT.cxx:2753
 TMatrixT.cxx:2754
 TMatrixT.cxx:2755
 TMatrixT.cxx:2756
 TMatrixT.cxx:2757
 TMatrixT.cxx:2758
 TMatrixT.cxx:2759
 TMatrixT.cxx:2760
 TMatrixT.cxx:2761
 TMatrixT.cxx:2762
 TMatrixT.cxx:2763
 TMatrixT.cxx:2764
 TMatrixT.cxx:2765
 TMatrixT.cxx:2766
 TMatrixT.cxx:2767
 TMatrixT.cxx:2768
 TMatrixT.cxx:2769
 TMatrixT.cxx:2770
 TMatrixT.cxx:2771
 TMatrixT.cxx:2772
 TMatrixT.cxx:2773
 TMatrixT.cxx:2774
 TMatrixT.cxx:2775
 TMatrixT.cxx:2776
 TMatrixT.cxx:2777
 TMatrixT.cxx:2778
 TMatrixT.cxx:2779
 TMatrixT.cxx:2780
 TMatrixT.cxx:2781
 TMatrixT.cxx:2782
 TMatrixT.cxx:2783
 TMatrixT.cxx:2784
 TMatrixT.cxx:2785
 TMatrixT.cxx:2786
 TMatrixT.cxx:2787
 TMatrixT.cxx:2788
 TMatrixT.cxx:2789
 TMatrixT.cxx:2790
 TMatrixT.cxx:2791
 TMatrixT.cxx:2792
 TMatrixT.cxx:2793
 TMatrixT.cxx:2794
 TMatrixT.cxx:2795
 TMatrixT.cxx:2796
 TMatrixT.cxx:2797
 TMatrixT.cxx:2798
 TMatrixT.cxx:2799
 TMatrixT.cxx:2800
 TMatrixT.cxx:2801
 TMatrixT.cxx:2802
 TMatrixT.cxx:2803
 TMatrixT.cxx:2804
 TMatrixT.cxx:2805
 TMatrixT.cxx:2806
 TMatrixT.cxx:2807
 TMatrixT.cxx:2808
 TMatrixT.cxx:2809
 TMatrixT.cxx:2810
 TMatrixT.cxx:2811
 TMatrixT.cxx:2812
 TMatrixT.cxx:2813
 TMatrixT.cxx:2814
 TMatrixT.cxx:2815
 TMatrixT.cxx:2816
 TMatrixT.cxx:2817
 TMatrixT.cxx:2818
 TMatrixT.cxx:2819
 TMatrixT.cxx:2820
 TMatrixT.cxx:2821
 TMatrixT.cxx:2822
 TMatrixT.cxx:2823
 TMatrixT.cxx:2824
 TMatrixT.cxx:2825
 TMatrixT.cxx:2826
 TMatrixT.cxx:2827
 TMatrixT.cxx:2828
 TMatrixT.cxx:2829
 TMatrixT.cxx:2830
 TMatrixT.cxx:2831
 TMatrixT.cxx:2832
 TMatrixT.cxx:2833
 TMatrixT.cxx:2834
 TMatrixT.cxx:2835
 TMatrixT.cxx:2836
 TMatrixT.cxx:2837
 TMatrixT.cxx:2838
 TMatrixT.cxx:2839
 TMatrixT.cxx:2840
 TMatrixT.cxx:2841
 TMatrixT.cxx:2842
 TMatrixT.cxx:2843
 TMatrixT.cxx:2844
 TMatrixT.cxx:2845
 TMatrixT.cxx:2846
 TMatrixT.cxx:2847
 TMatrixT.cxx:2848
 TMatrixT.cxx:2849
 TMatrixT.cxx:2850
 TMatrixT.cxx:2851
 TMatrixT.cxx:2852
 TMatrixT.cxx:2853
 TMatrixT.cxx:2854
 TMatrixT.cxx:2855
 TMatrixT.cxx:2856
 TMatrixT.cxx:2857
 TMatrixT.cxx:2858
 TMatrixT.cxx:2859
 TMatrixT.cxx:2860
 TMatrixT.cxx:2861
 TMatrixT.cxx:2862
 TMatrixT.cxx:2863
 TMatrixT.cxx:2864
 TMatrixT.cxx:2865
 TMatrixT.cxx:2866
 TMatrixT.cxx:2867
 TMatrixT.cxx:2868
 TMatrixT.cxx:2869
 TMatrixT.cxx:2870
 TMatrixT.cxx:2871
 TMatrixT.cxx:2872
 TMatrixT.cxx:2873
 TMatrixT.cxx:2874
 TMatrixT.cxx:2875
 TMatrixT.cxx:2876
 TMatrixT.cxx:2877
 TMatrixT.cxx:2878
 TMatrixT.cxx:2879
 TMatrixT.cxx:2880
 TMatrixT.cxx:2881
 TMatrixT.cxx:2882
 TMatrixT.cxx:2883
 TMatrixT.cxx:2884
 TMatrixT.cxx:2885
 TMatrixT.cxx:2886
 TMatrixT.cxx:2887
 TMatrixT.cxx:2888
 TMatrixT.cxx:2889
 TMatrixT.cxx:2890
 TMatrixT.cxx:2891
 TMatrixT.cxx:2892
 TMatrixT.cxx:2893
 TMatrixT.cxx:2894
 TMatrixT.cxx:2895
 TMatrixT.cxx:2896
 TMatrixT.cxx:2897
 TMatrixT.cxx:2898
 TMatrixT.cxx:2899
 TMatrixT.cxx:2900
 TMatrixT.cxx:2901
 TMatrixT.cxx:2902
 TMatrixT.cxx:2903
 TMatrixT.cxx:2904
 TMatrixT.cxx:2905
 TMatrixT.cxx:2906
 TMatrixT.cxx:2907
 TMatrixT.cxx:2908
 TMatrixT.cxx:2909
 TMatrixT.cxx:2910
 TMatrixT.cxx:2911
 TMatrixT.cxx:2912
 TMatrixT.cxx:2913
 TMatrixT.cxx:2914
 TMatrixT.cxx:2915
 TMatrixT.cxx:2916
 TMatrixT.cxx:2917
 TMatrixT.cxx:2918
 TMatrixT.cxx:2919
 TMatrixT.cxx:2920
 TMatrixT.cxx:2921
 TMatrixT.cxx:2922
 TMatrixT.cxx:2923
 TMatrixT.cxx:2924
 TMatrixT.cxx:2925
 TMatrixT.cxx:2926
 TMatrixT.cxx:2927
 TMatrixT.cxx:2928
 TMatrixT.cxx:2929
 TMatrixT.cxx:2930
 TMatrixT.cxx:2931
 TMatrixT.cxx:2932
 TMatrixT.cxx:2933
 TMatrixT.cxx:2934
 TMatrixT.cxx:2935
 TMatrixT.cxx:2936
 TMatrixT.cxx:2937
 TMatrixT.cxx:2938
 TMatrixT.cxx:2939
 TMatrixT.cxx:2940
 TMatrixT.cxx:2941
 TMatrixT.cxx:2942
 TMatrixT.cxx:2943
 TMatrixT.cxx:2944
 TMatrixT.cxx:2945
 TMatrixT.cxx:2946
 TMatrixT.cxx:2947
 TMatrixT.cxx:2948
 TMatrixT.cxx:2949
 TMatrixT.cxx:2950
 TMatrixT.cxx:2951
 TMatrixT.cxx:2952
 TMatrixT.cxx:2953
 TMatrixT.cxx:2954
 TMatrixT.cxx:2955
 TMatrixT.cxx:2956
 TMatrixT.cxx:2957
 TMatrixT.cxx:2958
 TMatrixT.cxx:2959
 TMatrixT.cxx:2960
 TMatrixT.cxx:2961
 TMatrixT.cxx:2962
 TMatrixT.cxx:2963
 TMatrixT.cxx:2964
 TMatrixT.cxx:2965
 TMatrixT.cxx:2966
 TMatrixT.cxx:2967
 TMatrixT.cxx:2968
 TMatrixT.cxx:2969
 TMatrixT.cxx:2970
 TMatrixT.cxx:2971
 TMatrixT.cxx:2972
 TMatrixT.cxx:2973
 TMatrixT.cxx:2974
 TMatrixT.cxx:2975
 TMatrixT.cxx:2976
 TMatrixT.cxx:2977
 TMatrixT.cxx:2978
 TMatrixT.cxx:2979
 TMatrixT.cxx:2980
 TMatrixT.cxx:2981
 TMatrixT.cxx:2982
 TMatrixT.cxx:2983
 TMatrixT.cxx:2984
 TMatrixT.cxx:2985
 TMatrixT.cxx:2986
 TMatrixT.cxx:2987
 TMatrixT.cxx:2988
 TMatrixT.cxx:2989
 TMatrixT.cxx:2990
 TMatrixT.cxx:2991
 TMatrixT.cxx:2992
 TMatrixT.cxx:2993
 TMatrixT.cxx:2994
 TMatrixT.cxx:2995
 TMatrixT.cxx:2996
 TMatrixT.cxx:2997
 TMatrixT.cxx:2998
 TMatrixT.cxx:2999
 TMatrixT.cxx:3000
 TMatrixT.cxx:3001
 TMatrixT.cxx:3002
 TMatrixT.cxx:3003
 TMatrixT.cxx:3004
 TMatrixT.cxx:3005
 TMatrixT.cxx:3006
 TMatrixT.cxx:3007
 TMatrixT.cxx:3008
 TMatrixT.cxx:3009
 TMatrixT.cxx:3010
 TMatrixT.cxx:3011
 TMatrixT.cxx:3012
 TMatrixT.cxx:3013
 TMatrixT.cxx:3014
 TMatrixT.cxx:3015
 TMatrixT.cxx:3016
 TMatrixT.cxx:3017
 TMatrixT.cxx:3018
 TMatrixT.cxx:3019
 TMatrixT.cxx:3020
 TMatrixT.cxx:3021
 TMatrixT.cxx:3022
 TMatrixT.cxx:3023
 TMatrixT.cxx:3024
 TMatrixT.cxx:3025
 TMatrixT.cxx:3026
 TMatrixT.cxx:3027
 TMatrixT.cxx:3028
 TMatrixT.cxx:3029
 TMatrixT.cxx:3030
 TMatrixT.cxx:3031
 TMatrixT.cxx:3032
 TMatrixT.cxx:3033
 TMatrixT.cxx:3034
 TMatrixT.cxx:3035
 TMatrixT.cxx:3036
 TMatrixT.cxx:3037
 TMatrixT.cxx:3038
 TMatrixT.cxx:3039
 TMatrixT.cxx:3040
 TMatrixT.cxx:3041
 TMatrixT.cxx:3042
 TMatrixT.cxx:3043
 TMatrixT.cxx:3044
 TMatrixT.cxx:3045
 TMatrixT.cxx:3046
 TMatrixT.cxx:3047
 TMatrixT.cxx:3048
 TMatrixT.cxx:3049
 TMatrixT.cxx:3050
 TMatrixT.cxx:3051
 TMatrixT.cxx:3052
 TMatrixT.cxx:3053
 TMatrixT.cxx:3054
 TMatrixT.cxx:3055
 TMatrixT.cxx:3056
 TMatrixT.cxx:3057
 TMatrixT.cxx:3058
 TMatrixT.cxx:3059
 TMatrixT.cxx:3060
 TMatrixT.cxx:3061
 TMatrixT.cxx:3062
 TMatrixT.cxx:3063
 TMatrixT.cxx:3064
 TMatrixT.cxx:3065
 TMatrixT.cxx:3066
 TMatrixT.cxx:3067
 TMatrixT.cxx:3068
 TMatrixT.cxx:3069
 TMatrixT.cxx:3070
 TMatrixT.cxx:3071
 TMatrixT.cxx:3072
 TMatrixT.cxx:3073
 TMatrixT.cxx:3074
 TMatrixT.cxx:3075
 TMatrixT.cxx:3076
 TMatrixT.cxx:3077
 TMatrixT.cxx:3078
 TMatrixT.cxx:3079
 TMatrixT.cxx:3080
 TMatrixT.cxx:3081
 TMatrixT.cxx:3082
 TMatrixT.cxx:3083
 TMatrixT.cxx:3084
 TMatrixT.cxx:3085
 TMatrixT.cxx:3086
 TMatrixT.cxx:3087
 TMatrixT.cxx:3088
 TMatrixT.cxx:3089
 TMatrixT.cxx:3090
 TMatrixT.cxx:3091
 TMatrixT.cxx:3092
 TMatrixT.cxx:3093
 TMatrixT.cxx:3094
 TMatrixT.cxx:3095
 TMatrixT.cxx:3096
 TMatrixT.cxx:3097
 TMatrixT.cxx:3098
 TMatrixT.cxx:3099
 TMatrixT.cxx:3100
 TMatrixT.cxx:3101
 TMatrixT.cxx:3102
 TMatrixT.cxx:3103
 TMatrixT.cxx:3104
 TMatrixT.cxx:3105
 TMatrixT.cxx:3106
 TMatrixT.cxx:3107
 TMatrixT.cxx:3108
 TMatrixT.cxx:3109
 TMatrixT.cxx:3110
 TMatrixT.cxx:3111
 TMatrixT.cxx:3112
 TMatrixT.cxx:3113
 TMatrixT.cxx:3114
 TMatrixT.cxx:3115
 TMatrixT.cxx:3116
 TMatrixT.cxx:3117
 TMatrixT.cxx:3118
 TMatrixT.cxx:3119
 TMatrixT.cxx:3120
 TMatrixT.cxx:3121
 TMatrixT.cxx:3122
 TMatrixT.cxx:3123
 TMatrixT.cxx:3124
 TMatrixT.cxx:3125
 TMatrixT.cxx:3126
 TMatrixT.cxx:3127
 TMatrixT.cxx:3128
 TMatrixT.cxx:3129
 TMatrixT.cxx:3130
 TMatrixT.cxx:3131
 TMatrixT.cxx:3132
 TMatrixT.cxx:3133
 TMatrixT.cxx:3134
 TMatrixT.cxx:3135
 TMatrixT.cxx:3136
 TMatrixT.cxx:3137
 TMatrixT.cxx:3138
 TMatrixT.cxx:3139
 TMatrixT.cxx:3140
 TMatrixT.cxx:3141
 TMatrixT.cxx:3142
 TMatrixT.cxx:3143
 TMatrixT.cxx:3144
 TMatrixT.cxx:3145
 TMatrixT.cxx:3146
 TMatrixT.cxx:3147
 TMatrixT.cxx:3148
 TMatrixT.cxx:3149
 TMatrixT.cxx:3150
 TMatrixT.cxx:3151
 TMatrixT.cxx:3152
 TMatrixT.cxx:3153
 TMatrixT.cxx:3154
 TMatrixT.cxx:3155
 TMatrixT.cxx:3156
 TMatrixT.cxx:3157
 TMatrixT.cxx:3158
 TMatrixT.cxx:3159
 TMatrixT.cxx:3160
 TMatrixT.cxx:3161
 TMatrixT.cxx:3162
 TMatrixT.cxx:3163
 TMatrixT.cxx:3164
 TMatrixT.cxx:3165
 TMatrixT.cxx:3166
 TMatrixT.cxx:3167
 TMatrixT.cxx:3168
 TMatrixT.cxx:3169
 TMatrixT.cxx:3170
 TMatrixT.cxx:3171
 TMatrixT.cxx:3172
 TMatrixT.cxx:3173
 TMatrixT.cxx:3174
 TMatrixT.cxx:3175
 TMatrixT.cxx:3176
 TMatrixT.cxx:3177
 TMatrixT.cxx:3178
 TMatrixT.cxx:3179
 TMatrixT.cxx:3180
 TMatrixT.cxx:3181
 TMatrixT.cxx:3182
 TMatrixT.cxx:3183
 TMatrixT.cxx:3184
 TMatrixT.cxx:3185
 TMatrixT.cxx:3186
 TMatrixT.cxx:3187
 TMatrixT.cxx:3188
 TMatrixT.cxx:3189
 TMatrixT.cxx:3190
 TMatrixT.cxx:3191
 TMatrixT.cxx:3192
 TMatrixT.cxx:3193
 TMatrixT.cxx:3194
 TMatrixT.cxx:3195
 TMatrixT.cxx:3196
 TMatrixT.cxx:3197
 TMatrixT.cxx:3198
 TMatrixT.cxx:3199
 TMatrixT.cxx:3200
 TMatrixT.cxx:3201
 TMatrixT.cxx:3202
 TMatrixT.cxx:3203
 TMatrixT.cxx:3204
 TMatrixT.cxx:3205
 TMatrixT.cxx:3206
 TMatrixT.cxx:3207
 TMatrixT.cxx:3208
 TMatrixT.cxx:3209
 TMatrixT.cxx:3210
 TMatrixT.cxx:3211
 TMatrixT.cxx:3212
 TMatrixT.cxx:3213
 TMatrixT.cxx:3214
 TMatrixT.cxx:3215
 TMatrixT.cxx:3216
 TMatrixT.cxx:3217
 TMatrixT.cxx:3218
 TMatrixT.cxx:3219
 TMatrixT.cxx:3220
 TMatrixT.cxx:3221
 TMatrixT.cxx:3222
 TMatrixT.cxx:3223
 TMatrixT.cxx:3224
 TMatrixT.cxx:3225
 TMatrixT.cxx:3226
 TMatrixT.cxx:3227
 TMatrixT.cxx:3228
 TMatrixT.cxx:3229
 TMatrixT.cxx:3230
 TMatrixT.cxx:3231
 TMatrixT.cxx:3232
 TMatrixT.cxx:3233
 TMatrixT.cxx:3234
 TMatrixT.cxx:3235
 TMatrixT.cxx:3236
 TMatrixT.cxx:3237
 TMatrixT.cxx:3238
 TMatrixT.cxx:3239
 TMatrixT.cxx:3240
 TMatrixT.cxx:3241
 TMatrixT.cxx:3242
 TMatrixT.cxx:3243
 TMatrixT.cxx:3244
 TMatrixT.cxx:3245
 TMatrixT.cxx:3246
 TMatrixT.cxx:3247
 TMatrixT.cxx:3248
 TMatrixT.cxx:3249
 TMatrixT.cxx:3250
 TMatrixT.cxx:3251
 TMatrixT.cxx:3252
 TMatrixT.cxx:3253
 TMatrixT.cxx:3254
 TMatrixT.cxx:3255
 TMatrixT.cxx:3256
 TMatrixT.cxx:3257
 TMatrixT.cxx:3258
 TMatrixT.cxx:3259
 TMatrixT.cxx:3260
 TMatrixT.cxx:3261
 TMatrixT.cxx:3262
 TMatrixT.cxx:3263
 TMatrixT.cxx:3264
 TMatrixT.cxx:3265
 TMatrixT.cxx:3266
 TMatrixT.cxx:3267
 TMatrixT.cxx:3268
 TMatrixT.cxx:3269
 TMatrixT.cxx:3270
 TMatrixT.cxx:3271
 TMatrixT.cxx:3272
 TMatrixT.cxx:3273
 TMatrixT.cxx:3274
 TMatrixT.cxx:3275
 TMatrixT.cxx:3276
 TMatrixT.cxx:3277
 TMatrixT.cxx:3278
 TMatrixT.cxx:3279
 TMatrixT.cxx:3280
 TMatrixT.cxx:3281
 TMatrixT.cxx:3282
 TMatrixT.cxx:3283
 TMatrixT.cxx:3284
 TMatrixT.cxx:3285
 TMatrixT.cxx:3286
 TMatrixT.cxx:3287
 TMatrixT.cxx:3288
 TMatrixT.cxx:3289
 TMatrixT.cxx:3290
 TMatrixT.cxx:3291
 TMatrixT.cxx:3292
 TMatrixT.cxx:3293
 TMatrixT.cxx:3294
 TMatrixT.cxx:3295
 TMatrixT.cxx:3296
 TMatrixT.cxx:3297
 TMatrixT.cxx:3298
 TMatrixT.cxx:3299
 TMatrixT.cxx:3300
 TMatrixT.cxx:3301
 TMatrixT.cxx:3302
 TMatrixT.cxx:3303
 TMatrixT.cxx:3304
 TMatrixT.cxx:3305
 TMatrixT.cxx:3306
 TMatrixT.cxx:3307
 TMatrixT.cxx:3308
 TMatrixT.cxx:3309
 TMatrixT.cxx:3310
 TMatrixT.cxx:3311
 TMatrixT.cxx:3312
 TMatrixT.cxx:3313
 TMatrixT.cxx:3314
 TMatrixT.cxx:3315
 TMatrixT.cxx:3316
 TMatrixT.cxx:3317
 TMatrixT.cxx:3318
 TMatrixT.cxx:3319
 TMatrixT.cxx:3320
 TMatrixT.cxx:3321
 TMatrixT.cxx:3322
 TMatrixT.cxx:3323
 TMatrixT.cxx:3324
 TMatrixT.cxx:3325
 TMatrixT.cxx:3326
 TMatrixT.cxx:3327
 TMatrixT.cxx:3328
 TMatrixT.cxx:3329
 TMatrixT.cxx:3330