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

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSym                                                          //
//                                                                      //
// Template class of a symmetric matrix in the linear algebra package   //
//                                                                      //
// Note that in this implementation both matrix element m[i][j] and     //
// m[j][i] are updated and stored in memory . However, when making the  //
// object persistent only the upper right triangle is stored .          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMatrixTSym.h"
#include "TMatrixTLazy.h"
#include "TMatrixTSymCramerInv.h"
#include "TDecompLU.h"
#include "TMatrixDSymEigen.h"
#include "TClass.h"
#include "TMath.h"

templateClassImp(TMatrixTSym)


//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(Int_t no_rows)
{
   Allocate(no_rows,no_rows,0,0,1);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(Int_t row_lwb,Int_t row_upb)
{
   const Int_t no_rows = row_upb-row_lwb+1;
   Allocate(no_rows,no_rows,row_lwb,row_lwb,1);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(Int_t no_rows,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_rows);
   SetMatrixArray(elements,option);
   if (!this->IsSymmetric()) {
      Error("TMatrixTSym(Int_t,Element*,Option_t*)","matrix not symmetric");
   }
}

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

   const Int_t no_rows = row_upb-row_lwb+1;
   Allocate(no_rows,no_rows,row_lwb,row_lwb);
   SetMatrixArray(elements,option);
   if (!this->IsSymmetric()) {
      Error("TMatrixTSym(Int_t,Int_t,Element*,Option_t*)","matrix not symmetric");
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(const TMatrixTSym<Element> &another) : TMatrixTBase<Element>(another)
{
   R__ASSERT(another.IsValid());
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(EMatrixCreatorsOp1 op,const TMatrixTSym<Element> &prototype)
{
  // Create a matrix applying a specific operation to the prototype.
  // Example: TMatrixTSym<Element> a(10,12); ...; TMatrixTSym<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);
         break;

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

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(EMatrixCreatorsOp1 op,const TMatrixT<Element> &prototype)
{
   R__ASSERT(prototype.IsValid());

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

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

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(const TMatrixTSym<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b)
{
   R__ASSERT(a.IsValid());
   R__ASSERT(b.IsValid());

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

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

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

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element>::TMatrixTSym(const TMatrixTSymLazy<Element> &lazy_constructor)
{
   Allocate(lazy_constructor.GetRowUpb()-lazy_constructor.GetRowLwb()+1,
            lazy_constructor.GetRowUpb()-lazy_constructor.GetRowLwb()+1,
            lazy_constructor.GetRowLwb(),lazy_constructor.GetRowLwb(),1);
   lazy_constructor.FillIn(*this);
   if (!this->IsSymmetric()) {
      Error("TMatrixTSym(TMatrixTSymLazy)","matrix not symmetric");
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSym<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* TMatrixTSym<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 TMatrixTSym<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 TMatrixTSym<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();
   this->fNrows   = 0;
   this->fNcols   = 0;
   this->fRowLwb  = 0;
   this->fColLwb  = 0;
   this->fNelems  = 0;
   fElements      = 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 TMatrixTSym<Element>::Plus(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b)
{
  // Symmetric 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 TMatrixTSym<Element>::Minus(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b)
{
  // Symmetric 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 TMatrixTSym<Element>::TMult(const TMatrixT<Element> &a)
{
  // Create a matrix C such that C = A' * A. In other words,
  // c[i,j] = SUM{ a[k,i] * a[k,j] }.

   R__ASSERT(a.IsValid());

#ifdef CBLAS
   const Element *ap = a.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(),ap,a.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(),ap,a.GetNcols(),1.0,cp,fNcols);
  else
      Error("TMult","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t nb     = a.GetNoElements();
   const Int_t ncolsa = a.GetNcols();
   const Int_t ncolsb = ncolsa;
  const Element * const ap = a.GetMatrixArray();
   const Element * const bp = ap;
         Element *       cp = this->GetMatrixArray();

   const Element *acp0 = ap;           // Pointer to  A[i,0];
   while (acp0 < ap+a.GetNcols()) {
      for (const Element *bcp = bp; bcp < bp+ncolsb; ) { // Pointer to the j-th column of A, Start bcp = A[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 A
            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
   }

   R__ASSERT(cp == this->GetMatrixArray()+this->fNelems && acp0 == ap+ncolsa);
#endif
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSym<Element>::TMult(const TMatrixTSym<Element> &a)
{
  // Matrix multiplication, with A symmetric
  // Create a matrix C such that C = A' * A = A * A = A * A'

   R__ASSERT(a.IsValid());

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

   const Element *acp0 = ap;           // Pointer to  A[i,0];
   while (acp0 < ap+a.GetNcols()) {
      for (const Element *bcp = bp; bcp < bp+ncolsb; ) { // Pointer to the j-th column of A, Start bcp = A[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 A
            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
   }

   R__ASSERT(cp == this->GetMatrixArray()+this->fNelems && acp0 == ap+ncolsa);
#endif
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::Use(Int_t row_lwb,Int_t row_upb,Element *data)
{
   if (gMatrixCheck && row_upb < row_lwb)
   {
      Error("Use","row_upb=%d < row_lwb=%d",row_upb,row_lwb);
      return *this;
   }

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

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::GetSub(Int_t row_lwb,Int_t row_upb,
                                                   TMatrixTSym<Element> &target,Option_t *option) const
{
  // Get submatrix [row_lwb..row_upb][row_lwb..row_upb]; The indexing range of the
  // returned matrix depends on the argument option:
  //
  // option == "S" : return [0..row_upb-row_lwb+1][0..row_upb-row_lwb+1] (default)
  // else          : return [row_lwb..row_upb][row_lwb..row_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 (row_upb < this->fRowLwb || row_upb > this->fRowLwb+this->fNrows-1) {
         Error("GetSub","row_upb out of bounds");
         return target;
      }
      if (row_upb < row_lwb) {
         Error("GetSub","row_upb < row_lwb");
         return target;
      }
   }

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

   Int_t row_lwb_sub;
   Int_t row_upb_sub;
   if (shift) {
      row_lwb_sub = 0;
      row_upb_sub = row_upb-row_lwb;
   } else {
      row_lwb_sub = row_lwb;
      row_upb_sub = row_upb;
   }

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

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

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

   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<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][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>
TMatrixTSym<Element> &TMatrixTSym<Element>::SetSub(Int_t row_lwb,const TMatrixTBase<Element> &source)
{
  // Insert matrix source starting at [row_lwb][row_lwb], thereby overwriting the part
  // [row_lwb..row_lwb+nrows_source][row_lwb..row_lwb+nrows_source];

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

      if (!source.IsSymmetric()) {
         Error("SetSub","source matrix is not symmetric");
         return *this;
      }
      if (row_lwb < this->fRowLwb || row_lwb > this->fRowLwb+this->fNrows-1) {
         Error("SetSub","row_lwb outof bounds");
         return *this;
      }
      if (row_lwb+source.GetNrows() > this->fRowLwb+this->fNrows) {
         Error("SetSub","source matrix too large");
         return *this;
      }
   }

   const Int_t nRows_source = source.GetNrows();

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

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

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<Element>::SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source)
{
  // Insert matrix source starting at [row_lwb][col_lwb] in a symmetric fashion, thereby overwriting the part
  // [row_lwb..row_lwb+nrows_source][row_lwb..row_lwb+nrows_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 out of bounds");
         return *this;
      }
      if (col_lwb < this->fColLwb || col_lwb > this->fColLwb+this->fNcols-1) {
         Error("SetSub","col_lwb out of bounds");
         return *this;
      }

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

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

   const Int_t rowlwb_s = source.GetRowLwb();
   const Int_t collwb_s = source.GetColLwb();
   if (row_lwb >= col_lwb) {
      // lower triangle
      Int_t irow;
      for (irow = 0; irow < nRows_source; irow++) {
         for (Int_t icol = 0; col_lwb+icol <= row_lwb+irow &&
                                icol < nCols_source; icol++) {
            (*this)(row_lwb+irow,col_lwb+icol) = source(irow+rowlwb_s,icol+collwb_s);
         }
      }

      // upper triangle
      for (irow = 0; irow < nCols_source; irow++) {
         for (Int_t icol = nRows_source-1; row_lwb+icol > irow+col_lwb &&
                                 icol >= 0; icol--) {
            (*this)(col_lwb+irow,row_lwb+icol) = source(icol+rowlwb_s,irow+collwb_s);
         }
      }
   } else {

   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<Element>::SetMatrixArray(const Element *data,Option_t *option)
{
   TMatrixTBase<Element>::SetMatrixArray(data,option);
   if (!this->IsSymmetric()) {
      Error("SetMatrixArray","Matrix is not symmetric after Set");
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<Element>::Shift(Int_t row_shift,Int_t col_shift)
{
   if (row_shift != col_shift) {
      Error("Shift","row_shift != col_shift");
      return *this;
   }
   return TMatrixTBase<Element>::Shift(row_shift,col_shift);
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<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 (nrows != ncols) {
      Error("ResizeTo(Int_t,Int_t)","nrows != ncols");
      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;
         this->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> &TMatrixTSym<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;
   }

   if (row_lwb != col_lwb) {
      Error("ResizeTo(Int_t,Int_t,Int_t,Int_t)","row_lwb != col_lwb");
      return *this;
   }
   if (row_upb != col_upb) {
      Error("ResizeTo(Int_t,Int_t,Int_t,Int_t)","row_upb != col_upb");
      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;
         this->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 ot 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 TMatrixTSym<Element>::Determinant() const
{
   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 TMatrixTSym<Element>::Determinant(Double_t &d1,Double_t &d2) const
{
   const TMatrixT<Element> &tmp = *this;
   TDecompLU lu(tmp,this->fTol);
   lu.Det(d1,d2);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::Invert(Double_t *det)
{
  // Invert the matrix and calculate its determinant
  // Notice that the LU decomposition is used instead of Bunch-Kaufman
  // Bunch-Kaufman guarantees a symmetric inverted matrix but is slower than LU .
  // The user can access Bunch-Kaufman through the TDecompBK class .

   R__ASSERT(this->IsValid());
   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>
TMatrixTSym<Element> &TMatrixTSym<Element>::InvertFast(Double_t *det)
{
  // Invert the matrix and calculate its determinant

   R__ASSERT(this->IsValid());

   const Char_t nRows = Char_t(this->GetNrows());
   switch (nRows) {
      case 1:
      {
         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:
      {
         TMatrixTSymCramerInv::Inv2x2<Element>(*this,det);
         return *this;
      }
      case 3:
      {
         TMatrixTSymCramerInv::Inv3x3<Element>(*this,det);
         return *this;
      }
      case 4:
      {
         TMatrixTSymCramerInv::Inv4x4<Element>(*this,det);
         return *this;
      }
      case 5:
      {
         TMatrixTSymCramerInv::Inv5x5<Element>(*this,det);
         return *this;
      }
      case 6:
      {
         TMatrixTSymCramerInv::Inv6x6<Element>(*this,det);
         return *this;
      }

      default:
      {
         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>
TMatrixTSym<Element> &TMatrixTSym<Element>::Transpose(const TMatrixTSym<Element> &source)
{
  // Transpose a matrix.

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

      if (this->fNrows != source.GetNcols() || this->fRowLwb != source.GetColLwb())
      {
         Error("Transpose","matrix has wrong shape");
         return *this;
      }
   }

   *this = source;
   return *this;
}

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

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

   const Element * const pv = v.GetMatrixArray();
         Element *trp = this->GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
         Element *tcp = trp;                    // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < this->fNrows; i++) {
      trp += i;               // point to [i,i]
      tcp += i*this->fNcols;  // point to [i,i]
      const Element tmp = alpha*pv[i];
      for (Int_t j = i; j < this->fNcols; j++) {
         if (j > i) *tcp += tmp*pv[j];
         *trp++ += tmp*pv[j];
         tcp += this->fNcols;
      }
      tcp -= this->fNelems-1; // point to [0,i]
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::Similarity(const TMatrixT<Element> &b)
{
// Calculate B * (*this) * B^T , final matrix will be (nrowsb x nrowsb)
// This is a similarity transform when B is orthogonal . It is more
// efficient than applying the actual multiplication because this
// routine realizes that  the final matrix is symmetric .

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(b.IsValid());
      if (this->fNcols != b.GetNcols() || this->fColLwb != b.GetColLwb()) {
         Error("Similarity(const TMatrixT &)","matrices incompatible");
         return *this;
      }
   }

   const Int_t ncolsa  = this->fNcols;
   const Int_t nb      = b.GetNoElements();
   const Int_t nrowsb  = b.GetNrows();
   const Int_t ncolsb  = b.GetNcols();

   const Element * const bp = b.GetMatrixArray();

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *bap = work;
   if (nrowsb*ncolsa > kWorkMax) {
      isAllocated = kTRUE;
      bap = new Element[nrowsb*ncolsa];
   }

   AMultB(bp,nb,ncolsb,this->fElements,this->fNelems,this->fNcols,bap);

   if (nrowsb != this->fNrows)
      this->ResizeTo(nrowsb,nrowsb);

#ifdef CBLAS
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasNoTrans,CblasTrans,this->fNrows,this->fNcols,ba.GetNcols(),
                   1.0,bap,ba.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasNoTrans,CblasTrans,this->fNrows,this->fNcols,ba.GetNcols(),
                   1.0,bap,ba.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else
      Error("Similarity","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t nba     = nrowsb*ncolsa;
   const Int_t ncolsba = ncolsa;
   const Element *       bi1p = bp;
         Element *       cp   = this->GetMatrixArray();
         Element * const cp0  = cp;

   Int_t ishift = 0;
   const Element *barp0 = bap;
   while (barp0 < bap+nba) {
      const Element *brp0 = bi1p;
      while (brp0 < bp+nb) {
         const Element *barp = barp0;
         const Element *brp  = brp0;
         Element cij = 0;
         while (brp < brp0+ncolsb)
            cij += *barp++ * *brp++;
         *cp++ = cij;
         brp0 += ncolsb;
      }
      barp0 += ncolsba;
      bi1p += ncolsb;
      cp += ++ishift;
   }

   R__ASSERT(cp == cp0+this->fNelems+ishift && barp0 == bap+nba);

   cp = cp0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      const Int_t rowOff1 = irow*this->fNrows;
      for (Int_t icol = 0; icol < irow; icol++) {
         const Int_t rowOff2 = icol*this->fNrows;
         cp[rowOff1+icol] = cp[rowOff2+irow];
      }
   }
#endif

   if (isAllocated)
      delete [] bap;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::Similarity(const TMatrixTSym<Element> &b)
{
// Calculate B * (*this) * B^T , final matrix will be (nrowsb x nrowsb)
// This is a similarity transform when B is orthogonal . It is more
// efficient than applying the actual multiplication because this
// routine realizes that  the final matrix is symmetric .

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      R__ASSERT(b.IsValid());
      if (this->fNcols != b.GetNcols() || this->fColLwb != b.GetColLwb()) {
         Error("Similarity(const TMatrixTSym &)","matrices incompatible");
         return *this;
      }
   }

#ifdef CBLAS
   const Int_t nrowsb = b.GetNrows();
   const Int_t ncolsa = this->GetNcols();

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *abtp = work;
   if (this->fNcols > kWorkMax) {
      isAllocated = kTRUE;
      abtp = new Element[this->fNcols];
   }

   const TMatrixT<Element> abt(*this,TMatrixT<Element>::kMultTranspose,b);

   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymm (CblasRowMajor,CblasLeft,CblasUpper,this->fNrows,this->fNcols,1.0,
                   bp,b.GetNcols(),abtp,abt.GetNcols(),0.0,cp,this->fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymm (CblasRowMajor,CblasLeft,CblasUpper,this->fNrows,this->fNcols,1.0,
                   bp,b.GetNcols(),abtp,abt.GetNcols(),0.0,cp,this->fNcols);
   else
      Error("Similarity","type %s not implemented in BLAS library",typeid(Element));

   if (isAllocated)
      delete [] abtp;
#else
   const Int_t ncolsa = this->GetNcols();
   const Int_t nb     = b.GetNoElements();
   const Int_t nrowsb = b.GetNrows();
   const Int_t ncolsb = b.GetNcols();

   const Element * const bp = b.GetMatrixArray();

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *bap = work;
   if (nrowsb*ncolsa > kWorkMax) {
      isAllocated = kTRUE;
      bap = new Element[nrowsb*ncolsa];
   }

   AMultB(bp,nb,ncolsb,this->fElements,this->fNelems,this->fNcols,bap);

   const Int_t nba     = nrowsb*ncolsa;
   const Int_t ncolsba = ncolsa;
   const Element *       bi1p = bp;
         Element *       cp   = this->GetMatrixArray();
         Element * const cp0  = cp;

   Int_t ishift = 0;
   const Element *barp0 = bap;
   while (barp0 < bap+nba) {
      const Element *brp0 = bi1p;
      while (brp0 < bp+nb) {
         const Element *barp = barp0;
         const Element *brp  = brp0;
         Element cij = 0;
         while (brp < brp0+ncolsb)
            cij += *barp++ * *brp++;
         *cp++ = cij;
         brp0 += ncolsb;
      }
      barp0 += ncolsba;
      bi1p += ncolsb;
      cp += ++ishift;
   }

   R__ASSERT(cp == cp0+this->fNelems+ishift && barp0 == bap+nba);

   cp = cp0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      const Int_t rowOff1 = irow*this->fNrows;
      for (Int_t icol = 0; icol < irow; icol++) {
         const Int_t rowOff2 = icol*this->fNrows;
         cp[rowOff1+icol] = cp[rowOff2+irow];
      }
   }

   if (isAllocated)
      delete [] bap;
#endif

   return *this;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSym<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 != 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>
TMatrixTSym<Element> &TMatrixTSym<Element>::SimilarityT(const TMatrixT<Element> &b)
{
// Calculate B^T * (*this) * B , final matrix will be (ncolsb x ncolsb)
// It is more efficient than applying the actual multiplication because this
// routine realizes that  the final matrix is symmetric .

  if (gMatrixCheck) {
     R__ASSERT(this->IsValid());
     R__ASSERT(b.IsValid());
     if (this->fNrows != b.GetNrows() || this->fRowLwb != b.GetRowLwb()) {
        Error("SimilarityT(const TMatrixT &)","matrices incompatible");
        return *this;
     }
  }

   const Int_t ncolsb = b.GetNcols();
   const Int_t ncolsa = this->GetNcols();

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *btap = work;
   if (ncolsb*ncolsa > kWorkMax) {
      isAllocated = kTRUE;
      btap = new Element[ncolsb*ncolsa];
   }

   TMatrixT<Element> bta; bta.Use(ncolsb,ncolsa,btap);
   bta.TMult(b,*this);

   if (ncolsb != this->fNcols)
      this->ResizeTo(ncolsb,ncolsb);

#ifdef CBLAS
   const Element *bp = b.GetMatrixArray();
         Element *cp = this->GetMatrixArray();
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemm (CblasRowMajor,CblasNoTrans,CblasNoTrans,this->fNrows,this->fNcols,bta.GetNcols(),
                   1.0,btap,bta.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemm (CblasRowMajor,CblasNoTrans,CblasNoTrans,this->fNrows,this->fNcols,bta.GetNcols(),
                   1.0,btap,bta.GetNcols(),bp,b.GetNcols(),1.0,cp,this->fNcols);
   else
      Error("similarityT","type %s not implemented in BLAS library",typeid(Element));
#else
   const Int_t nbta     = bta.GetNoElements();
   const Int_t nb       = b.GetNoElements();
   const Int_t ncolsbta = bta.GetNcols();
   const Element * const bp   = b.GetMatrixArray();
         Element *       cp   = this->GetMatrixArray();
         Element * const cp0  = cp;

   Int_t ishift = 0;
   const Element *btarp0 = btap;                     // Pointer to  A[i,0];
   const Element *bcp0   = bp;
   while (btarp0 < btap+nbta) {
      for (const Element *bcp = bcp0; bcp < bp+ncolsb; ) { // Pointer to the j-th column of B, Start bcp = B[0,0]
         const Element *btarp = btarp0;                   // 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 += *btarp++ * *bcp;                     // the j-th col of B
            bcp += ncolsb;
         }
         *cp++ = cij;
         bcp -= nb-1;                                  // Set bcp to the (j+1)-th col
      }
      btarp0 += ncolsbta;                             // Set ap to the (i+1)-th row
      bcp0++;
      cp += ++ishift;
   }

   R__ASSERT(cp == cp0+this->fNelems+ishift && btarp0 == btap+nbta);

   cp = cp0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      const Int_t rowOff1 = irow*this->fNrows;
      for (Int_t icol = 0; icol < irow; icol++) {
         const Int_t rowOff2 = icol*this->fNrows;
         cp[rowOff1+icol] = cp[rowOff2+irow];
      }
   }
#endif

   if (isAllocated)
      delete [] btap;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::operator=(const TMatrixTSym<Element> &source)
{
   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=","matrices not compatible");
      return *this;
   }

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

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::operator=(const TMatrixTSymLazy<Element> &lazy_constructor)
{
   R__ASSERT(this->IsValid());

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

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

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator+=","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>
TMatrixTSym<Element> &TMatrixTSym<Element>::operator-=(const TMatrixTSym<Element> &source)
{
  // Subtract the source matrix.

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator-=","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>
TMatrixTBase<Element> &TMatrixTSym<Element>::Apply(const TElementActionT<Element> &action)
{
   R__ASSERT(this->IsValid());

   Element val = 0;
   Element *trp = this->GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
   Element *tcp = trp;                    // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < this->fNrows; i++) {
      trp += i;               // point to [i,i]
      tcp += i*this->fNcols;  // point to [i,i]
      for (Int_t j = i; j < this->fNcols; j++) {
         action.Operation(val);
         if (j > i) *tcp = val;
         *trp++ = val;
         tcp += this->fNcols;
      }
      tcp -= this->fNelems-1; // point to [0,i]
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<Element>::Apply(const TElementPosActionT<Element> &action)
{
  // Apply action to each element of the matrix. To action the location
  // of the current element is passed.

   R__ASSERT(this->IsValid());

   Element val = 0;
   Element *trp = this->GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
   Element *tcp = trp;                    // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < this->fNrows; i++) {
      action.fI = i+this->fRowLwb;
      trp += i;               // point to [i,i]
      tcp += i*this->fNcols;  // point to [i,i]
      for (Int_t j = i; j < this->fNcols; j++) {
         action.fJ = j+this->fColLwb;
         action.Operation(val);
         if (j > i) *tcp = val;
         *trp++ = val;
         tcp += this->fNcols;
      }
      tcp -= this->fNelems-1; // point to [0,i]
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSym<Element>::Randomize(Element alpha,Element beta,Double_t &seed)
{
  // randomize matrix element values but keep matrix symmetric

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      if (this->fNrows != this->fNcols || this->fRowLwb != this->fColLwb) {
         Error("Randomize(Element,Element,Element &","matrix should be square");
         return *this;
      }
   }

   const Element scale = beta-alpha;
   const Element shift = alpha/scale;

   Element *ep = GetMatrixArray();
   for (Int_t i = 0; i < this->fNrows; i++) {
      const Int_t off = i*this->fNcols;
      for (Int_t j = 0; j <= i; j++) {
         ep[off+j] = scale*(Drand(seed)+shift);
         if (i != j) {
            ep[j*this->fNcols+i] = ep[off+j];
         }
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> &TMatrixTSym<Element>::RandomizePD(Element alpha,Element beta,Double_t &seed)
{
  // randomize matrix element values but keep matrix symmetric positive definite

   if (gMatrixCheck) {
      R__ASSERT(this->IsValid());
      if (this->fNrows != this->fNcols || this->fRowLwb != this->fColLwb) {
         Error("RandomizeSym(Element,Element,Element &","matrix should be square");
         return *this;
      }
   }

   const Element scale = beta-alpha;
   const Element shift = alpha/scale;

   Element *ep = GetMatrixArray();
   Int_t i;
   for (i = 0; i < this->fNrows; i++) {
      const Int_t off = i*this->fNcols;
      for (Int_t j = 0; j <= i; j++)
         ep[off+j] = scale*(Drand(seed)+shift);
   }

   for (i = this->fNrows-1; i >= 0; i--) {
      const Int_t off1 = i*this->fNcols;
      for (Int_t j = i; j >= 0; j--) {
         const Int_t off2 = j*this->fNcols;
         ep[off1+j] *= ep[off2+j];
         for (Int_t k = j-1; k >= 0; k--) {
            ep[off1+j] += ep[off1+k]*ep[off2+k];
         }
         if (i != j)
            ep[off2+i] = ep[off1+j];
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
const TMatrixT<Element> TMatrixTSym<Element>::EigenVectors(TVectorT<Element> &eigenValues) const
{
  // Return a matrix containing the eigen-vectors ordered by descending eigen-values.
  // For full functionality use TMatrixDSymEigen .

   TMatrixDSym tmp = *this;
   TMatrixDSymEigen eigen(tmp);
   eigenValues.ResizeTo(this->fNrows);
   eigenValues = eigen.GetEigenValues();
   return eigen.GetEigenVectors();
}

//______________________________________________________________________________
template<class Element>
Bool_t operator==(const TMatrixTSym<Element> &m1,const TMatrixTSym<Element> &m2)
{
  // Check to see if two matrices are identical.

   if (!AreCompatible(m1,m2)) return kFALSE;
   return (memcmp(m1.GetMatrixArray(),m2.GetMatrixArray(),
                  m1.GetNoElements()*sizeof(Element)) == 0);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator+(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
   TMatrixTSym<Element> target(source1);
   target += source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator+(const TMatrixTSym<Element> &source1,Element val)
{
   TMatrixTSym<Element> target(source1);
   target += val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator+(Element val,const TMatrixTSym<Element> &source1)
{
   return operator+(source1,val);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator-(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
   TMatrixTSym<Element> target(source1);
   target -= source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator-(const TMatrixTSym<Element> &source1,Element val)
{
   TMatrixTSym<Element> target(source1);
   target -= val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator-(Element val,const TMatrixTSym<Element> &source1)
{
   return Element(-1.0)*operator-(source1,val);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator*(const TMatrixTSym<Element> &source1,Element val)
{
   TMatrixTSym<Element> target(source1);
   target *= val;
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSym<Element> operator*(Element val,const TMatrixTSym<Element> &source1)
{
  return operator*(source1,val);
}

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

   TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator&&(const TMatrixTSym&,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>
TMatrixTSym<Element> operator||(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
  // Logical Or

   TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator||(const TMatrixTSym&,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>
TMatrixTSym<Element> operator>(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
  // source1 > source2

  TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator>(const TMatrixTSym&,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>
TMatrixTSym<Element> operator>=(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
  // source1 >= source2

   TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator>=(const TMatrixTSym&,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>
TMatrixTSym<Element> operator<=(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
  // source1 <= source2

   TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<=(const TMatrixTSym&,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>
TMatrixTSym<Element> operator<(const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2)
{
  // source1 < source2

  TMatrixTSym<Element> target;

   if (gMatrixCheck && !AreCompatible(source1,source2)) {
      Error("operator<(const TMatrixTSym&,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>
TMatrixTSym<Element> &Add(TMatrixTSym<Element> &target,Element scalar,const TMatrixTSym<Element> &source)
{
   // Modify addition: target += scalar * source.

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

   const Int_t nrows  = target.GetNrows();
   const Int_t ncols  = target.GetNcols();
   const Int_t nelems = target.GetNoElements();
   const Element *sp  = source.GetMatrixArray();
         Element *trp = target.GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
         Element *tcp = target.GetMatrixArray(); // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < nrows; i++) {
      sp  += i;
      trp += i;        // point to [i,i]
      tcp += i*ncols;  // point to [i,i]
      for (Int_t j = i; j < ncols; j++) {
         const Element tmp = scalar * *sp++;
         if (j > i) *tcp += tmp;
         *trp++ += tmp;
         tcp += ncols;
      }
      tcp -= nelems-1; // point to [0,i]
   }

   return target;
}

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

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

   const Int_t nrows  = target.GetNrows();
   const Int_t ncols  = target.GetNcols();
   const Int_t nelems = target.GetNoElements();
   const Element *sp  = source.GetMatrixArray();
         Element *trp = target.GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
         Element *tcp = target.GetMatrixArray(); // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < nrows; i++) {
      sp  += i;
      trp += i;        // point to [i,i]
      tcp += i*ncols;  // point to [i,i]
      for (Int_t j = i; j < ncols; j++) {
         if (j > i) *tcp *= *sp;
         *trp++ *= *sp++;
         tcp += ncols;
      }
      tcp -= nelems-1; // point to [0,i]
   }

   return target;
}

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

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

   const Int_t nrows  = target.GetNrows();
   const Int_t ncols  = target.GetNcols();
   const Int_t nelems = target.GetNoElements();
   const Element *sp  = source.GetMatrixArray();
         Element *trp = target.GetMatrixArray(); // pointer to UR part and diagonal, traverse row-wise
         Element *tcp = target.GetMatrixArray(); // pointer to LL part,              traverse col-wise
   for (Int_t i = 0; i < nrows; i++) {
      sp  += i;
      trp += i;        // point to [i,i]
      tcp += i*ncols;  // point to [i,i]
      for (Int_t j = i; j < ncols; j++) {
         if (*sp != 0.0) {
            if (j > i) *tcp /= *sp;
            *trp++ /= *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);
            trp++;
         }
         tcp += ncols;
      }
      tcp -= nelems-1; // point to [0,i]
   }

   return target;
}

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

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      Clear();
      R__b.ReadClassBuffer(TMatrixTBase<Element>::Class(),this,R__v,R__s,R__c);
      fElements = new Element[this->fNelems];
      Int_t i;
      for (i = 0; i < this->fNrows; i++) {
         R__b.ReadFastArray(fElements+i*this->fNcols+i,this->fNcols-i);
      }
      // copy to Lower left triangle
      for (i = 0; i < this->fNrows; i++) {
         for (Int_t j = 0; j < i; j++) {
            fElements[i*this->fNcols+j] = fElements[j*this->fNrows+i];
        }
      }
      if (this->fNelems <= this->kSizeMax) {
         memcpy(fDataStack,fElements,this->fNelems*sizeof(Element));
         delete [] fElements;
         fElements = fDataStack;
      }
   } else {
      R__b.WriteClassBuffer(TMatrixTBase<Element>::Class(),this);
      // Only write the Upper right triangle
      for (Int_t i = 0; i < this->fNrows; i++) {
         R__b.WriteFastArray(fElements+i*this->fNcols+i,this->fNcols-i);
      }
   }
}

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

template class TMatrixTSym<Float_t>;

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

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

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

template class TMatrixTSym<Double_t>;

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

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