ROOT logo
// @(#)root/matrix:$Id: TMatrixTSparse.cxx 25272 2008-08-27 06:28:00Z brun $
// Authors: Fons Rademakers, Eddy Offermann   Feb 2004

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSparse                                                       //
//                                                                      //
// Template class of a general sparse matrix in the Harwell-Boeing      //
// format                                                               //
//                                                                      //
// Besides the usual shape/size decsriptors of a matrix like fNrows,    //
// fRowLwb,fNcols and fColLwb, we also store a row index, fRowIndex and //
// column index, fColIndex only for those elements unequal zero:        //
//                                                                      //
// fRowIndex[0,..,fNrows]:    Stores for each row the index range of    //
//                            the elements in the data and column array //
// fColIndex[0,..,fNelems-1]: Stores the column number for each data    //
//                            element != 0                              //
//                                                                      //
// As an example how to access all sparse data elements:                //
//                                                                      //
// for (Int_t irow = 0; irow < this->fNrows; irow++) {                  //
//   const Int_t sIndex = fRowIndex[irow];                              //
//   const Int_t eIndex = fRowIndex[irow+1];                            //
//   for (Int_t index = sIndex; index < eIndex; index++) {              //
//     const Int_t icol = fColIndex[index];                             //
//     const Element data = fElements[index];                           //
//     printf("data(%d,%d) = %.4e\n",irow+this->fRowLwb,icol+           //
//                                               this->fColLwb,data);   //
//   }                                                                  //
// }                                                                    //
//                                                                      //
// When checking whether sparse matrices are compatible (like in an     //
// assigment !), not only the shape parameters are compared but also    //
// the sparse structure through fRowIndex and fColIndex .               //
//                                                                      //
// Several methods exist to fill a sparse matrix with data entries.     //
// Most are the same like for dense matrices but some care has to be    //
// taken with regard to performance. In the constructor, always the     //
// shape of the matrix has to be specified in some form . Data can be   //
// entered through the following methods :                              //
// 1. constructor                                                       //
//    TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,         //
//                   Int_t col_upb,Int_t nr_nonzeros,                   //
//                   Int_t *row, Int_t *col,Element *data);            //
//    It uses SetMatrixArray(..), see below                             //
// 2. copy constructors                                                 //
// 3. SetMatrixArray(Int_t nr,Int_t *irow,Int_t *icol,Element *data)   //
//    where it is expected that the irow,icol and data array contain    //
//    nr entries . Only the entries with non-zero data[i] value are     //
//    inserted !                                                        //
// 4. TMatrixTSparse a(n,m); for(....) { a(i,j) = ....                  //
//    This is a very flexible method but expensive :                    //
//    - if no entry for slot (i,j) is found in the sparse index table   //
//      it will be entered, which involves some memory management !     //
//    - before invoking this method in a loop it is smart to first      //
//      set the index table through a call to SetSparseIndex(..)        //
// 5. SetSub(Int_t row_lwb,Int_t col_lwb,const TMatrixTBase &source)    //
//    the matrix to be inserted at position (row_lwb,col_lwb) can be    //
//    both dense or sparse .                                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMatrixTSparse.h"
#include "TMatrixT.h"
#include "TMath.h"

#ifndef R__ALPHA
templateClassImp(TMatrixTSparse)
#endif

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(Int_t no_rows,Int_t no_cols)
{
  // Space is allocated for row/column indices and data, but the sparse structure
  // information has still to be set !

   Allocate(no_rows,no_cols,0,0,1);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)
{
  // Space is allocated for row/column indices and data, but the sparse structure
  // information has still to be set !

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                        Int_t nr,Int_t *row, Int_t *col,Element *data)
{
  // Space is allocated for row/column indices and data. Sparse row/column index
  // structure together with data is coming from the arrays, row, col and data, resp .

   const Int_t irowmin = TMath::LocMin(nr,row);
   const Int_t irowmax = TMath::LocMax(nr,row);
   const Int_t icolmin = TMath::LocMin(nr,col);
   const Int_t icolmax = TMath::LocMax(nr,col);

   if (row[irowmin] < row_lwb || row[irowmax] > row_upb) {
      Error("TMatrixTSparse","Inconsistency between row index and its range");
      if (row[irowmin] < row_lwb) {
         Info("TMatrixTSparse","row index lower bound adjusted to %d",row[irowmin]);
         row_lwb = row[irowmin];
      }
      if (row[irowmax] > row_upb) {
         Info("TMatrixTSparse","row index upper bound adjusted to %d",row[irowmax]);
         col_lwb = col[irowmax];
      }
   }
   if (col[icolmin] < col_lwb || col[icolmax] > col_upb) {
      Error("TMatrixTSparse","Inconsistency between column index and its range");
      if (col[icolmin] < col_lwb) {
         Info("TMatrixTSparse","column index lower bound adjusted to %d",col[icolmin]);
         col_lwb = col[icolmin];
      }
      if (col[icolmax] > col_upb) {
         Info("TMatrixTSparse","column index upper bound adjusted to %d",col[icolmax]);
         col_upb = col[icolmax];
      }
   }

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

   SetMatrixArray(nr,row,col,data);
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(const TMatrixTSparse<Element> &another) : TMatrixTBase<Element>(another)
{
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb(),1,
            another.GetNoElements());
   memcpy(fRowIndex,another.GetRowIndexArray(),this->fNrowIndex*sizeof(Int_t));
   memcpy(fColIndex,another.GetColIndexArray(),this->fNelems*sizeof(Int_t));

   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(const TMatrixT<Element> &another) : TMatrixTBase<Element>(another)
{
   const Int_t nr_nonzeros = another.NonZeros();
   Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb(),1,nr_nonzeros);
   SetSparseIndex(another);
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(EMatrixCreatorsOp1 op,const TMatrixTSparse<Element> &prototype)
{
  // Create a matrix applying a specific operation to the prototype.
  // Supported operations are: kZero, kUnit, kTransposed and kAtA

   R__ASSERT(prototype.IsValid());

   Int_t nr_nonzeros = 0;

   switch(op) {
      case kZero:
      {
         Allocate(prototype.GetNrows(),prototype.GetNcols(),
                  prototype.GetRowLwb(),prototype.GetColLwb(),1,nr_nonzeros);
         break;
      }
      case kUnit:
      {
         const Int_t nrows  = prototype.GetNrows();
         const Int_t ncols  = prototype.GetNcols();
         const Int_t rowLwb = prototype.GetRowLwb();
         const Int_t colLwb = prototype.GetColLwb();
         for (Int_t i = rowLwb; i <= rowLwb+nrows-1; i++)
            for (Int_t j = colLwb; j <= colLwb+ncols-1; j++)
               if (i==j) nr_nonzeros++;
            Allocate(nrows,ncols,rowLwb,colLwb,1,nr_nonzeros);
            UnitMatrix();
            break;
      }
      case kTransposed:
      {
          Allocate(prototype.GetNcols(), prototype.GetNrows(),
                   prototype.GetColLwb(),prototype.GetRowLwb(),1,prototype.GetNoElements());
          Transpose(prototype);
          break;
      }
      case kAtA:
      {
         const TMatrixTSparse<Element> at(TMatrixTSparse<Element>::kTransposed,prototype);
         AMultBt(at,at,1);
         break;
      }

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element>::TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSparse<Element> &b)
{
  // Create a matrix applying a specific operation to two prototypes.
  // Supported operations are: kMult (a*b), kMultTranspose (a*b'), kPlus (a+b), kMinus (a-b)

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

   switch(op) {
      case kMult:
         AMultB(a,b,1);
         break;

      case kMultTranspose:
         AMultBt(a,b,1);
         break;

      case kPlus:
         APlusB(a,b,1);
         break;

      case kMinus:
         AMinusB(a,b,1);
         break;

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

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<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), 0 initialization flag and number of non-zero
  // elements (only relevant for sparse format).

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

   this->MakeValid();
   this->fNrows     = no_rows;
   this->fNcols     = no_cols;
   this->fRowLwb    = row_lwb;
   this->fColLwb    = col_lwb;
   this->fNrowIndex = this->fNrows+1;
   this->fNelems    = nr_nonzeros;
   this->fIsOwner   = kTRUE;
   this->fTol       = std::numeric_limits<Element>::epsilon();

   fRowIndex = new Int_t[this->fNrowIndex];
   if (init)
      memset(fRowIndex,0,this->fNrowIndex*sizeof(Int_t));

   if (this->fNelems > 0) {
      fElements = new Element[this->fNelems];
      fColIndex = new Int_t   [this->fNelems];
      if (init) {
         memset(fElements,0,this->fNelems*sizeof(Element));
         memset(fColIndex,0,this->fNelems*sizeof(Int_t));
      }
   } else {
      fElements = 0;
      fColIndex = 0;
   }
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<Element>::InsertRow(Int_t rown,Int_t coln,const Element *v,Int_t n)
{
  // Insert in row rown, n elements of array v at column coln

   const Int_t arown = rown-this->fRowLwb;
   const Int_t acoln = coln-this->fColLwb;
   const Int_t nr = (n > 0) ? n : this->fNcols;

   if (gMatrixCheck) {
      if (arown >= this->fNrows || arown < 0) {
         Error("InsertRow","row %d out of matrix range",rown);
         return *this;
      }

      if (acoln >= this->fNcols || acoln < 0) {
         Error("InsertRow","column %d out of matrix range",coln);
         return *this;
      }

      if (acoln+nr > this->fNcols || nr < 0) {
         Error("InsertRow","row length %d out of range",nr);
         return *this;
      }
   }

   const Int_t sIndex = fRowIndex[arown];
   const Int_t eIndex = fRowIndex[arown+1];

   // check first how many slots are available from [acoln,..,acoln+nr-1]
   // also note lIndex and rIndex so that [sIndex..lIndex] and [rIndex..eIndex-1]
   // contain the row entries except for the region to be inserted

   Int_t nslots = 0;
   Int_t lIndex = sIndex-1;
   Int_t rIndex = sIndex-1;
   Int_t index;
   for (index = sIndex; index < eIndex; index++) {
      const Int_t icol = fColIndex[index];
      rIndex++;
      if (icol >= acoln+nr) break;
      if (icol >= acoln) nslots++;
      else               lIndex++;
   }

   const Int_t nelems_old = this->fNelems;
   const Int_t    *colIndex_old = fColIndex;
   const Element *elements_old = fElements;

   const Int_t ndiff = nr-nslots;
   this->fNelems += ndiff;
   fColIndex = new Int_t[this->fNelems];
   fElements = new Element[this->fNelems];

   for (Int_t irow = arown+1; irow < this->fNrows+1; irow++)
      fRowIndex[irow] += ndiff;

   if (lIndex+1 > 0) {
      memmove(fColIndex,colIndex_old,(lIndex+1)*sizeof(Int_t));
      memmove(fElements,elements_old,(lIndex+1)*sizeof(Element));
   }

   if (nelems_old > 0 && nelems_old-rIndex > 0) {
      memmove(fColIndex+rIndex+ndiff,colIndex_old+rIndex,(nelems_old-rIndex)*sizeof(Int_t));
      memmove(fElements+rIndex+ndiff,elements_old+rIndex,(nelems_old-rIndex)*sizeof(Element));
   }

   index = lIndex+1;
   for (Int_t i = 0; i < nr; i++) {
      fColIndex[index] = acoln+i;
      fElements[index] = v[i];
      index++;
   }

   if (colIndex_old) delete [] (Int_t*)    colIndex_old;
   if (elements_old) delete [] (Element*) elements_old;

   R__ASSERT(this->fNelems == fRowIndex[this->fNrowIndex-1]);

   return *this;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::ExtractRow(Int_t rown, Int_t coln, Element *v,Int_t n) const
{
  // Store in array v, n matrix elements of row rown starting at column coln

   const Int_t arown = rown-this->fRowLwb;
   const Int_t acoln = coln-this->fColLwb;
   const Int_t nr = (n > 0) ? n : this->fNcols;

   if (gMatrixCheck) {
      if (arown >= this->fNrows || arown < 0) {
         Error("ExtractRow","row %d out of matrix range",rown);
         return;
      }

      if (acoln >= this->fNcols || acoln < 0) {
         Error("ExtractRow","column %d out of matrix range",coln);
         return;
      }

      if (acoln+nr > this->fNcols || nr < 0) {
         Error("ExtractRow","row length %d out of range",nr);
         return;
      }
   }

   const Int_t sIndex = fRowIndex[arown];
   const Int_t eIndex = fRowIndex[arown+1];

   memset(v,0,nr*sizeof(Element));
   const Int_t   * const pColIndex = GetColIndexArray();
   const Element * const pData     = GetMatrixArray();
   for (Int_t index = sIndex; index < eIndex; index++) {
      const Int_t icol = pColIndex[index];
      if (icol < acoln || icol >= acoln+nr) continue;
       v[icol-acoln] = pData[index];
   }
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMultBt(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr)
{
  // General matrix multiplication. Create a matrix C such that C = A * B'.
  // Note, matrix C is allocated for constr=1.

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

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

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMultB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMultB","this = &b");
         return;
      }
   }

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();
   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   Int_t *pRowIndexc;
   Int_t *pColIndexc;
   if (constr) {
      // make a best guess of the sparse structure; it will guarantee
      // enough allocated space !

      Int_t nr_nonzero_rowa = 0;
      {
         for (Int_t irowa = 0; irowa < a.GetNrows(); irowa++)
            if (pRowIndexa[irowa] < pRowIndexa[irowa+1])
               nr_nonzero_rowa++;
      }
      Int_t nr_nonzero_rowb = 0;
      {
         for (Int_t irowb = 0; irowb < b.GetNrows(); irowb++)
            if (pRowIndexb[irowb] < pRowIndexb[irowb+1])
              nr_nonzero_rowb++;
      }

      Int_t nc = nr_nonzero_rowa*nr_nonzero_rowb; // best guess
      Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1,nc);

      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();

      pRowIndexc[0] = 0;
      Int_t ielem = 0;
      for (Int_t irowa = 0; irowa < a.GetNrows(); irowa++) {
         pRowIndexc[irowa+1] = pRowIndexc[irowa];
         if (pRowIndexa[irowa] >= pRowIndexa[irowa+1]) continue;
         for (Int_t irowb = 0; irowb < b.GetNrows(); irowb++) {
            if (pRowIndexb[irowb] >= pRowIndexb[irowb+1]) continue;
            pRowIndexc[irowa+1]++;
            pColIndexc[ielem++] = irowb;
         }
      }
   } else {
      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();
   }

   const Element * const pDataa = a.GetMatrixArray();
   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t shift = 0;
   Int_t indexc_r = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         const Int_t sIndexb = pRowIndexb[icolc];
         const Int_t eIndexb = pRowIndexb[icolc+1];
         Element sum = 0.0;
         Int_t indexb = sIndexb;
         for (Int_t indexa = sIndexa; indexa < eIndexa && indexb < eIndexb; indexa++) {
            const Int_t icola = pColIndexa[indexa];
            while (indexb < eIndexb && pColIndexb[indexb] <= icola) {
               if (icola == pColIndexb[indexb]) {
                 sum += pDataa[indexa]*pDatab[indexb];
                 break;
               }
               indexb++;
            }
         }
         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMultBt(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr)
{
  // General matrix multiplication. Create a matrix C such that C = A * B'.
  // Note, matrix C is allocated for constr=1.

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

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

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMultB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMultB","this = &b");
         return;
      }
   }

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();

   Int_t *pRowIndexc;
   Int_t *pColIndexc;
   if (constr) {
      // make a best guess of the sparse structure; it will guarantee
      // enough allocated space !

      Int_t nr_nonzero_rowa = 0;
      {
         for (Int_t irowa = 0; irowa < a.GetNrows(); irowa++)
            if (pRowIndexa[irowa] < pRowIndexa[irowa+1])
               nr_nonzero_rowa++;
      }
      Int_t nr_nonzero_rowb = b.GetNrows();

      Int_t nc = nr_nonzero_rowa*nr_nonzero_rowb; // best guess
      Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1,nc);

      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();

      pRowIndexc[0] = 0;
      Int_t ielem = 0;
      for (Int_t irowa = 0; irowa < a.GetNrows(); irowa++) {
         pRowIndexc[irowa+1] = pRowIndexc[irowa];
         for (Int_t irowb = 0; irowb < b.GetNrows(); irowb++) {
            pRowIndexc[irowa+1]++;
            pColIndexc[ielem++] = irowb;
         }
      }
   } else {
      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();
   }

   const Element * const pDataa = a.GetMatrixArray();
   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         const Int_t off   = icolc*b.GetNcols();
         Element sum = 0.0;
         for (Int_t indexa = sIndexa; indexa < eIndexa; indexa++) {
            const Int_t icola = pColIndexa[indexa];
            sum += pDataa[indexa]*pDatab[off+icola];
         }
         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMultBt(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr)
{
  // General matrix multiplication. Create a matrix C such that C = A * B'.
  // Note, matrix C is allocated for constr=1.

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

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

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMultB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMultB","this = &b");
         return;
      }
   }

   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   Int_t *pRowIndexc;
   Int_t *pColIndexc;
   if (constr) {
      // make a best guess of the sparse structure; it will guarantee
      // enough allocated space !

      Int_t nr_nonzero_rowa = a.GetNrows();
      Int_t nr_nonzero_rowb = 0;
      {
         for (Int_t irowb = 0; irowb < b.GetNrows(); irowb++)
            if (pRowIndexb[irowb] < pRowIndexb[irowb+1])
               nr_nonzero_rowb++;
      }

      Int_t nc = nr_nonzero_rowa*nr_nonzero_rowb; // best guess
      Allocate(a.GetNrows(),b.GetNrows(),a.GetRowLwb(),b.GetRowLwb(),1,nc);

      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();

      pRowIndexc[0] = 0;
      Int_t ielem = 0;
      for (Int_t irowa = 0; irowa < a.GetNrows(); irowa++) {
         pRowIndexc[irowa+1] = pRowIndexc[irowa];
         for (Int_t irowb = 0; irowb < b.GetNrows(); irowb++) {
            if (pRowIndexb[irowb] >= pRowIndexb[irowb+1]) continue;
            pRowIndexc[irowa+1]++;
            pColIndexc[ielem++] = irowb;
         }
      }
   } else {
      pRowIndexc = this->GetRowIndexArray();
      pColIndexc = this->GetColIndexArray();
   }

   const Element * const pDataa = a.GetMatrixArray();
   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t off   = irowc*a.GetNcols();
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         const Int_t sIndexb = pRowIndexb[icolc];
         const Int_t eIndexb = pRowIndexb[icolc+1];
         Element sum = 0.0;
         for (Int_t indexb = sIndexb; indexb < eIndexb; indexb++) {
            const Int_t icolb = pColIndexb[indexb];
            sum += pDataa[off+icolb]*pDatab[indexb];
         }
         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::APlusB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr)
{
  // General matrix addition. Create a matrix C such that C = A + B.
  // Note, matrix C is allocated for constr=1.

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
         Error("APlusB(const TMatrixTSparse &,const TMatrixTSparse &","matrices not compatible");
         return;
      }

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("APlusB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("APlusB","this = &b");
         return;
      }
   }

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   if (constr) {
      Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb());
      SetSparseIndexAB(a,b);
   }

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   const Element * const pDataa = a.GetMatrixArray();
   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      const Int_t sIndexb = pRowIndexb[irowc];
      const Int_t eIndexb = pRowIndexb[irowc+1];
      Int_t indexa = sIndexa;
      Int_t indexb = sIndexb;
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         Element sum = 0.0;
         while (indexa < eIndexa && pColIndexa[indexa] <= icolc) {
            if (icolc == pColIndexa[indexa]) {
               sum += pDataa[indexa];
               break;
            }
            indexa++;
         }
         while (indexb < eIndexb && pColIndexb[indexb] <= icolc) {
            if (icolc == pColIndexb[indexb]) {
               sum += pDatab[indexb];
               break;
            }
            indexb++;
         }

         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::APlusB(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr)
{
  // General matrix addition. Create a matrix C such that C = A + B.
  // Note, matrix C is allocated for constr=1.

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
         Error("APlusB(const TMatrixTSparse &,const TMatrixT &","matrices not compatible");
         return;
      }

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("APlusB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("APlusB","this = &b");
         return;
      }
   }

   if (constr)
      *this = b;

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();

   const Element * const pDataa = a.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      Int_t indexa = sIndexa;
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         Element sum = pDatac[indexc];
         while (indexa < eIndexa && pColIndexa[indexa] <= icolc) {
            if (icolc == pColIndexa[indexa]) {
               sum += pDataa[indexa];
               break;
            }
            indexa++;
         }

         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMinusB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr)
{
  // General matrix subtraction. Create a matrix C such that C = A - B.
  // Note, matrix C is allocated for constr=1.

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
         Error("AMinusB(const TMatrixTSparse &,const TMatrixTSparse &","matrices not compatible");
         return;
      }

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMinusB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMinusB","this = &b");
         return;
      }
   }

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   if (constr) {
      Allocate(a.GetNrows(),a.GetNcols(),a.GetRowLwb(),a.GetColLwb());
      SetSparseIndexAB(a,b);
   }

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   const Element * const pDataa = a.GetMatrixArray();
   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      const Int_t sIndexb = pRowIndexb[irowc];
      const Int_t eIndexb = pRowIndexb[irowc+1];
      Int_t indexa = sIndexa;
      Int_t indexb = sIndexb;
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         Element sum = 0.0;
         while (indexa < eIndexa && pColIndexa[indexa] <= icolc) {
            if (icolc == pColIndexa[indexa]) {
               sum += pDataa[indexa];
               break;
            }
            indexa++;
          }
         while (indexb < eIndexb && pColIndexb[indexb] <= icolc) {
            if (icolc == pColIndexb[indexb]) {
               sum -= pDatab[indexb];
               break;
            }
            indexb++;
         }

         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMinusB(const TMatrixTSparse<Element> &a,const TMatrixT<Element> &b,Int_t constr)
{
  // General matrix subtraction. Create a matrix C such that C = A - B.
  // Note, matrix C is allocated for constr=1.

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
          Error("AMinusB(const TMatrixTSparse &,const TMatrixT &","matrices not compatible");
          return;
      }

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMinusB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMinusB","this = &b");
         return;
      }
   }

   if (constr)
      *this = b;

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();

   const Element * const pDataa = a.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      Int_t indexa = sIndexa;
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         Element sum = -pDatac[indexc];
         while (indexa < eIndexa && pColIndexa[indexa] <= icolc) {
            if (icolc == pColIndexa[indexa]) {
               sum += pDataa[indexa];
               break;
            }
            indexa++;
         }

         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::AMinusB(const TMatrixT<Element> &a,const TMatrixTSparse<Element> &b,Int_t constr)
{
  // General matrix subtraction. Create a matrix C such that C = A - B.
  // Note, matrix C is allocated for constr=1.

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
         Error("AMinusB(const TMatrixT &,const TMatrixTSparse &","matrices not compatible");
         return;
      }

      if (!constr && this->GetMatrixArray() == a.GetMatrixArray()) {
         Error("AMinusB","this = &a");
         return;
      }

      if (!constr && this->GetMatrixArray() == b.GetMatrixArray()) {
         Error("AMinusB","this = &b");
         return;
      }
   }

   if (constr)
      *this = a;

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   const Element * const pDatab = b.GetMatrixArray();
   Element * const pDatac = this->GetMatrixArray();
   Int_t indexc_r = 0;
   Int_t shift = 0;
   for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) {
      const Int_t sIndexc = pRowIndexc[irowc]+shift;
      const Int_t eIndexc = pRowIndexc[irowc+1];
      const Int_t sIndexb = pRowIndexb[irowc];
      const Int_t eIndexb = pRowIndexb[irowc+1];
      Int_t indexb = sIndexb;
      for (Int_t indexc = sIndexc; indexc < eIndexc; indexc++) {
         const Int_t icolc = pColIndexc[indexc];
         Element sum = pDatac[indexc];
         while (indexb < eIndexb && pColIndexb[indexb] <= icolc) {
            if (icolc == pColIndexb[indexb]) {
               sum -= pDatab[indexb];
               break;
            }
            indexb++;
         }

         if (!constr)
            pDatac[indexc] = sum;
         else {
            if (sum != 0.0) {
               pRowIndexc[irowc+1]  = indexc_r+1;
               pColIndexc[indexc_r] = icolc;
               pDatac[indexc_r] = sum;
               indexc_r++;
            } else
               shift++;
         }
      }
   }

   if (constr)
      SetSparseIndex(indexc_r);
}

//______________________________________________________________________________
template<class Element>
void TMatrixTSparse<Element>::GetMatrix2Array(Element *data,Option_t * /*option*/) const
{
  // Copy matrix data to array . It is assumed that array is of size >= fNelems

   R__ASSERT(this->IsValid());

   const Element * const elem = GetMatrixArray();
   memcpy(data,elem,this->fNelems*sizeof(Element));
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<Element>::SetMatrixArray(Int_t nr,Int_t *row,Int_t *col,Element *data)
{
  // Copy nr elements from row/col index and data array to matrix . It is assumed
  // that arrays are of size >= nr

   R__ASSERT(this->IsValid());
   if (nr <= 0) {
      Error("SetMatrixArray(Int_t,Int_t*,Int_t*,Element*","nr <= 0");
      return *this;
   }

   const Int_t irowmin = TMath::LocMin(nr,row);
   const Int_t irowmax = TMath::LocMax(nr,row);
   const Int_t icolmin = TMath::LocMin(nr,col);
   const Int_t icolmax = TMath::LocMax(nr,col);

   R__ASSERT(row[irowmin] >= this->fRowLwb && row[irowmax] <= this->fRowLwb+this->fNrows-1);
   R__ASSERT(col[icolmin] >= this->fColLwb && col[icolmax] <= this->fColLwb+this->fNcols-1);

   if (row[irowmin] < this->fRowLwb || row[irowmax] > this->fRowLwb+this->fNrows-1) {
      Error("SetMatrixArray","Inconsistency between row index and its range");
      if (row[irowmin] < this->fRowLwb) {
         Info("SetMatrixArray","row index lower bound adjusted to %d",row[irowmin]);
         this->fRowLwb = row[irowmin];
      }
      if (row[irowmax] > this->fRowLwb+this->fNrows-1) {
         Info("SetMatrixArray","row index upper bound adjusted to %d",row[irowmax]);
         this->fNrows = row[irowmax]-this->fRowLwb+1;
      }
   }
   if (col[icolmin] < this->fColLwb || col[icolmax] > this->fColLwb+this->fNcols-1) {
      Error("SetMatrixArray","Inconsistency between column index and its range");
      if (col[icolmin] < this->fColLwb) {
         Info("SetMatrixArray","column index lower bound adjusted to %d",col[icolmin]);
         this->fColLwb = col[icolmin];
      }
      if (col[icolmax] > this->fColLwb+this->fNcols-1) {
         Info("SetMatrixArray","column index upper bound adjusted to %d",col[icolmax]);
         this->fNcols = col[icolmax]-this->fColLwb+1;
      }
   }

   DoubleLexSort(nr,row,col,data);

   Int_t nr_nonzeros = 0;
   const Element *ep        = data;
   const Element * const fp = data+nr;

   while (ep < fp)
      if (*ep++ != 0.0) nr_nonzeros++;

   // if nr_nonzeros != this->fNelems
   if (nr_nonzeros != this->fNelems) {
      if (fColIndex) { delete [] fColIndex; fColIndex = 0; }
      if (fElements) { delete [] fElements; fElements = 0; }
      this->fNelems = nr_nonzeros;
      if (this->fNelems > 0) {
         fColIndex = new Int_t[nr_nonzeros];
         fElements = new Element[nr_nonzeros];
      } else {
         fColIndex = 0;
         fElements = 0;
      }
   }

   if (this->fNelems <= 0)
      return *this;

   fRowIndex[0] = 0;
   Int_t ielem = 0;
   nr_nonzeros = 0;
   for (Int_t irow = 1; irow < this->fNrows+1; irow++) {
      if (ielem < nr && row[ielem] < irow) {
         while (ielem < nr) {
            if (data[ielem] != 0.0) {
               fColIndex[nr_nonzeros] = col[ielem]-this->fColLwb;
               fElements[nr_nonzeros] = data[ielem];
               nr_nonzeros++;
            }
            ielem++;
            if (ielem >= nr || row[ielem] != row[ielem-1])
               break;
         }
      }
      fRowIndex[irow] = nr_nonzeros;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::SetSparseIndex(Int_t nelems_new)
{
  // Increase/decrease the number of non-zero elements to nelems_new

   if (nelems_new != this->fNelems) {
      Int_t nr = TMath::Min(nelems_new,this->fNelems);
      Int_t *oIp = fColIndex;
      fColIndex = new Int_t[nelems_new];
      memmove(fColIndex,oIp,nr*sizeof(Int_t));
      if (oIp) delete [] oIp;
      Element *oDp = fElements;
      fElements = new Element[nelems_new];
      memmove(fElements,oDp,nr*sizeof(Element));
      if (oDp) delete [] oDp;
      this->fNelems = nelems_new;
      if (nelems_new > nr) {
         memset(fElements+nr,0,(nelems_new-nr)*sizeof(Element));
         memset(fColIndex+nr,0,(nelems_new-nr)*sizeof(Int_t));
      } else {
         for (Int_t irow = 0; irow < this->fNrowIndex; irow++)
            if (fRowIndex[irow] > nelems_new)
               fRowIndex[irow] = nelems_new;
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::SetSparseIndex(const TMatrixTBase<Element> &source)
{
  // Use non-zero data of matrix source to set the sparse structure

   if (gMatrixCheck) {
      R__ASSERT(source.IsValid());
      if (this->GetNrows()  != source.GetNrows()  || this->GetNcols()  != source.GetNcols() ||
          this->GetRowLwb() != source.GetRowLwb() || this->GetColLwb() != source.GetColLwb()) {
         Error("SetSparseIndex","matrices not compatible");
         return *this;
      }
   }

   const Int_t nr_nonzeros = source.NonZeros();

   if (nr_nonzeros != this->fNelems)
      SetSparseIndex(nr_nonzeros);

   if (source.GetRowIndexArray() && source.GetColIndexArray()) {
      memmove(fRowIndex,source.GetRowIndexArray(),this->fNrowIndex*sizeof(Int_t));
      memmove(fColIndex,source.GetColIndexArray(),this->fNelems*sizeof(Int_t));
   } else {
      const Element *ep = source.GetMatrixArray();
      Int_t nr = 0;
      for (Int_t irow = 0; irow < this->fNrows; irow++) {
         fRowIndex[irow] = nr;
         for (Int_t icol = 0; icol < this->fNcols; icol++) {
            if (*ep != 0.0) {
               fColIndex[nr] = icol;
               nr++;
            }
            ep++;
         }
      }
      fRowIndex[this->fNrows] = nr;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::SetSparseIndexAB(const TMatrixTSparse<Element> &a,const TMatrixTSparse<Element> &b)
{
  // Set the row/column indices to the "sum" of matrices a and b
  // It is checked that enough space has been allocated

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

      if (a.GetNrows()  != b.GetNrows()  || a.GetNcols()  != b.GetNcols() ||
          a.GetRowLwb() != b.GetRowLwb() || a.GetColLwb() != b.GetColLwb()) {
         Error("SetSparseIndexAB","source matrices not compatible");
         return *this;
      }

      if (this->GetNrows()  != a.GetNrows()  || this->GetNcols()  != a.GetNcols() ||
          this->GetRowLwb() != a.GetRowLwb() || this->GetColLwb() != a.GetColLwb()) {
         Error("SetSparseIndexAB","matrix not compatible with source matrices");
         return *this;
      }
   }

   const Int_t * const pRowIndexa = a.GetRowIndexArray();
   const Int_t * const pRowIndexb = b.GetRowIndexArray();
   const Int_t * const pColIndexa = a.GetColIndexArray();
   const Int_t * const pColIndexb = b.GetColIndexArray();

   Int_t nc = 0, irowc;
   for (irowc = 0; irowc < a.GetNrows(); irowc++) {
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      const Int_t sIndexb = pRowIndexb[irowc];
      const Int_t eIndexb = pRowIndexb[irowc+1];
      nc += eIndexa-sIndexa;
      Int_t indexb = sIndexb;
      for (Int_t indexa = sIndexa; indexa < eIndexa; indexa++) {
         const Int_t icola = pColIndexa[indexa];
         for (; indexb < eIndexb; indexb++) {
            if (pColIndexb[indexb] >= icola) {
               if (pColIndexb[indexb] == icola)
                  indexb++;
               break;
            }
            nc++;
         }
      }
      while (indexb < eIndexb) {
         if (pColIndexb[indexb++] > pColIndexa[eIndexa-1])
            nc++;
      }
   }

   if (this->NonZeros() != nc)
      SetSparseIndex(nc);

   Int_t * const pRowIndexc = this->GetRowIndexArray();
   Int_t * const pColIndexc = this->GetColIndexArray();

   nc = 0;
   pRowIndexc[0] = 0;
   for (irowc = 0; irowc < a.GetNrows(); irowc++) {
      const Int_t sIndexa = pRowIndexa[irowc];
      const Int_t eIndexa = pRowIndexa[irowc+1];
      const Int_t sIndexb = pRowIndexb[irowc];
      const Int_t eIndexb = pRowIndexb[irowc+1];
      Int_t indexb = sIndexb;
      for (Int_t indexa = sIndexa; indexa < eIndexa; indexa++) {
         const Int_t icola = pColIndexa[indexa];
         for (; indexb < eIndexb; indexb++) {
            if (pColIndexb[indexb] >= icola) {
               if (pColIndexb[indexb] == icola)
                  indexb++;
               break;
            }
            pColIndexc[nc++] = pColIndexb[indexb];
         }
         pColIndexc[nc++] = pColIndexa[indexa];
      }
      while (indexb < eIndexb) {
         if (pColIndexb[indexb++] > pColIndexa[eIndexa-1])
            pColIndexc[nc++] = pColIndexb[indexb-1];
      }
      pRowIndexc[irowc+1] = nc;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<Element>::ResizeTo(Int_t nrows,Int_t ncols,Int_t nr_nonzeros)
{
  // Set size of the matrix to nrows x ncols with nr_nonzeros non-zero entries
  // if nr_nonzeros > 0 .
  // 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,Int_t)","Not owner of data array,cannot resize");
      return *this;
   }

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

      const Element *elements_old = GetMatrixArray();
      const Int_t   *rowIndex_old = GetRowIndexArray();
      const Int_t   *colIndex_old = GetColIndexArray();

      Int_t nrows_old     = this->fNrows;
      Int_t nrowIndex_old = this->fNrowIndex;

      Int_t nelems_new;
      if (nr_nonzeros > 0)
         nelems_new = nr_nonzeros;
      else {
         nelems_new = 0;
         for (Int_t irow = 0; irow < nrows_old; irow++) {
            if (irow >= nrows) continue;
            const Int_t sIndex = rowIndex_old[irow];
            const Int_t eIndex = rowIndex_old[irow+1];
            for (Int_t index = sIndex; index < eIndex; index++) {
               const Int_t icol = colIndex_old[index];
               if (icol < ncols)
                  nelems_new++;
            }
         }
      }

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

      Element *elements_new = GetMatrixArray();
      Int_t   *rowIndex_new = GetRowIndexArray();
      Int_t   *colIndex_new = GetColIndexArray();

      Int_t nelems_copy = 0;
      rowIndex_new[0] = 0;
      Bool_t cont = kTRUE;
      for (Int_t irow = 0; irow < nrows_old && cont; irow++) {
         if (irow >= nrows) continue;
         const Int_t sIndex = rowIndex_old[irow];
         const Int_t eIndex = rowIndex_old[irow+1];
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = colIndex_old[index];
            if (icol < ncols) {
               rowIndex_new[irow+1]      = nelems_copy+1;
               colIndex_new[nelems_copy] = icol;
               elements_new[nelems_copy] = elements_old[index];
               nelems_copy++;
            }
            if (nelems_copy >= nelems_new) {
               cont = kFALSE;
               break;
            }
         }
      }

      if (rowIndex_old) delete [] (Int_t*)   rowIndex_old;
      if (colIndex_old) delete [] (Int_t*)   colIndex_old;
      if (elements_old) delete [] (Element*) elements_old;

      if (nrowIndex_old < this->fNrowIndex) {
          for (Int_t irow = nrowIndex_old; irow < this->fNrowIndex; irow++)
            rowIndex_new[irow] = rowIndex_new[nrowIndex_old-1];
      }
   } else {
      const Int_t nelems_new = (nr_nonzeros >= 0) ? nr_nonzeros : 0;
      Allocate(nrows,ncols,0,0,1,nelems_new);
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<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] with nr_nonzeros
  // non-zero entries if nr_nonzeros > 0 .
  // 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,Int_t)","Not owner of data array,cannot resize");
      return *this;
   }

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

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

      const Int_t   *rowIndex_old = GetRowIndexArray();
      const Int_t   *colIndex_old = GetColIndexArray();
      const Element *elements_old = GetMatrixArray();

      const Int_t  nrowIndex_old = this->fNrowIndex;

      const Int_t  nrows_old     = this->fNrows;
      const Int_t  rowLwb_old    = this->fRowLwb;
      const Int_t  colLwb_old    = this->fColLwb;

      Int_t nelems_new;
      if (nr_nonzeros > 0)
         nelems_new = nr_nonzeros;
      else {
         nelems_new = 0;
         for (Int_t irow = 0; irow < nrows_old; irow++) {
            if (irow+rowLwb_old > row_upb || irow+rowLwb_old < row_lwb) continue;
            const Int_t sIndex = rowIndex_old[irow];
            const Int_t eIndex = rowIndex_old[irow+1];
            for (Int_t index = sIndex; index < eIndex; index++) {
               const Int_t icol = colIndex_old[index];
               if (icol+colLwb_old <= col_upb && icol+colLwb_old >= col_lwb)
                  nelems_new++;
            }
         }
      }

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

      Int_t    *rowIndex_new = GetRowIndexArray();
      Int_t    *colIndex_new = GetColIndexArray();
      Element *elements_new = GetMatrixArray();

      Int_t nelems_copy = 0;
      rowIndex_new[0] = 0;
      Bool_t cont = kTRUE;
      const Int_t row_off = rowLwb_old-row_lwb;
      const Int_t col_off = colLwb_old-col_lwb;
      for (Int_t irow = 0; irow < nrows_old; irow++) {
         if (irow+rowLwb_old > row_upb || irow+rowLwb_old < row_lwb) continue;
         const Int_t sIndex = rowIndex_old[irow];
         const Int_t eIndex = rowIndex_old[irow+1];
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = colIndex_old[index];
            if (icol+colLwb_old <= col_upb && icol+colLwb_old >= col_lwb) {
               rowIndex_new[irow+row_off+1] = nelems_copy+1;
               colIndex_new[nelems_copy]    = icol+col_off;
               elements_new[nelems_copy]    = elements_old[index];
               nelems_copy++;
            }
            if (nelems_copy >= nelems_new) {
               cont = kFALSE;
               break;
            }
         }
      }

      if (rowIndex_old) delete [] (Int_t*)   rowIndex_old;
      if (colIndex_old) delete [] (Int_t*)   colIndex_old;
      if (elements_old) delete [] (Element*) elements_old;

      if (nrowIndex_old < this->fNrowIndex) {
         for (Int_t irow = nrowIndex_old; irow < this->fNrowIndex; irow++)
            rowIndex_new[irow] = rowIndex_new[nrowIndex_old-1];
      }
   } else {
      const Int_t nelems_new = (nr_nonzeros >= 0) ? nr_nonzeros : 0;
      Allocate(new_nrows,new_ncols,row_lwb,col_lwb,1,nelems_new);
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::Use(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                                      Int_t nr_nonzeros,Int_t *pRowIndex,Int_t *pColIndex,Element *pData)
{
   if (gMatrixCheck) {
      if (row_upb < row_lwb) {
         Error("Use","row_upb=%d < row_lwb=%d",row_upb,row_lwb);
         return *this;
      }
      if (col_upb < col_lwb) {
         Error("Use","col_upb=%d < col_lwb=%d",col_upb,col_lwb);
         return *this;
      }
   }

   Clear();

   this->fNrows     = row_upb-row_lwb+1;
   this->fNcols     = col_upb-col_lwb+1;
   this->fRowLwb    = row_lwb;
   this->fColLwb    = col_lwb;
   this->fNrowIndex = this->fNrows+1;
   this->fNelems    = nr_nonzeros;
   this->fIsOwner   = kFALSE;
   this->fTol       = std::numeric_limits<Element>::epsilon();

   fElements  = pData;
   fRowIndex  = pRowIndex;
   fColIndex  = pColIndex;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<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;

   Int_t nr_nonzeros = 0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      if (irow+this->fRowLwb > row_upb || irow+this->fRowLwb < row_lwb) continue;
      const Int_t sIndex = fRowIndex[irow];
      const Int_t eIndex = fRowIndex[irow+1];
      for (Int_t index = sIndex; index < eIndex; index++) {
         const Int_t icol = fColIndex[index];
         if (icol+this->fColLwb <= col_upb && icol+this->fColLwb >= col_lwb)
            nr_nonzeros++;
      }
   }

   target.ResizeTo(row_lwb_sub,row_upb_sub,col_lwb_sub,col_upb_sub,nr_nonzeros);

   const Element *ep = this->GetMatrixArray();

   Int_t   *rowIndex_sub = target.GetRowIndexArray();
   Int_t   *colIndex_sub = target.GetColIndexArray();
   Element *ep_sub       = target.GetMatrixArray();

   if (target.GetRowIndexArray() && target.GetColIndexArray()) {
      Int_t nelems_copy = 0;
      rowIndex_sub[0] = 0;
      const Int_t row_off = this->fRowLwb-row_lwb;
      const Int_t col_off = this->fColLwb-col_lwb;
      for (Int_t irow = 0; irow < this->fNrows; irow++) {
         if (irow+this->fRowLwb > row_upb || irow+this->fRowLwb < row_lwb) continue;
         const Int_t sIndex = fRowIndex[irow];
         const Int_t eIndex = fRowIndex[irow+1];
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = fColIndex[index];
            if (icol+this->fColLwb <= col_upb && icol+this->fColLwb >= col_lwb) {
               rowIndex_sub[irow+row_off+1] = nelems_copy+1;
               colIndex_sub[nelems_copy]    = icol+col_off;
               ep_sub[nelems_copy]          = ep[index];
               nelems_copy++;
            }
         }
      }
   } else {
      const Int_t row_off = this->fRowLwb-row_lwb;
      const Int_t col_off = this->fColLwb-col_lwb;
      const Int_t ncols_sub = col_upb_sub-col_lwb_sub+1;
      for (Int_t irow = 0; irow < this->fNrows; irow++) {
         if (irow+this->fRowLwb > row_upb || irow+this->fRowLwb < row_lwb) continue;
         const Int_t sIndex = fRowIndex[irow];
         const Int_t eIndex = fRowIndex[irow+1];
         const Int_t off = (irow+row_off)*ncols_sub;
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = fColIndex[index];
            if (icol+this->fColLwb <= col_upb && icol+this->fColLwb >= col_lwb)
               ep_sub[off+icol+col_off] = ep[index];
         }
      }
    }

   return target;
}

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

   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->fColLwb+this->fNcols) {
         Error("SetSub","source matrix too large");
         return *this;
      }
   }

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

   // Determine how many non-zero's are already available in
   // [row_lwb..row_lwb+nrows_source-1][col_lwb..col_lwb+ncols_source-1]
   Int_t nr_nonzeros = 0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      if (irow+this->fRowLwb >= row_lwb+nRows_source || irow+this->fRowLwb < row_lwb) continue;
      const Int_t sIndex = fRowIndex[irow];
      const Int_t eIndex = fRowIndex[irow+1];
      for (Int_t index = sIndex; index < eIndex; index++) {
         const Int_t icol = fColIndex[index];
         if (icol+this->fColLwb < col_lwb+nCols_source && icol+this->fColLwb >= col_lwb)
            nr_nonzeros++;
      }
   }

   const Int_t   *rowIndex_s = source.GetRowIndexArray();
   const Int_t   *colIndex_s = source.GetColIndexArray();
   const Element *elements_s = source.GetMatrixArray();

   const Int_t nelems_old = this->fNelems;
   const Int_t   *rowIndex_old = GetRowIndexArray();
   const Int_t   *colIndex_old = GetColIndexArray();
   const Element *elements_old = GetMatrixArray();

   const Int_t nelems_new = nelems_old+source.NonZeros()-nr_nonzeros;
   fRowIndex = new Int_t[this->fNrowIndex];
   fColIndex = new Int_t[nelems_new];
   fElements = new Element[nelems_new];
   this->fNelems   = nelems_new;

   Int_t   *rowIndex_new = GetRowIndexArray();
   Int_t   *colIndex_new = GetColIndexArray();
   Element *elements_new = GetMatrixArray();

   const Int_t row_off = row_lwb-this->fRowLwb;
   const Int_t col_off = col_lwb-this->fColLwb;

   Int_t nr = 0;
   rowIndex_new[0] = 0;
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      rowIndex_new[irow+1] = rowIndex_new[irow];
      Bool_t flagRow = kFALSE;
      if (irow+this->fRowLwb < row_lwb+nRows_source && irow+this->fRowLwb >= row_lwb)
         flagRow = kTRUE;

      const Int_t sIndex_o = rowIndex_old[irow];
      const Int_t eIndex_o = rowIndex_old[irow+1];

      if (flagRow) {
         const Int_t icol_left = col_off-1;
         const Int_t left = TMath::BinarySearch(eIndex_o-sIndex_o,colIndex_old+sIndex_o,icol_left)+sIndex_o;
         for (Int_t index = sIndex_o; index <= left; index++) {
            rowIndex_new[irow+1]++;
            colIndex_new[nr] = colIndex_old[index];
            elements_new[nr] = elements_old[index];
            nr++;
         }

         if (rowIndex_s && colIndex_s) {
            const Int_t sIndex_s = rowIndex_s[irow-row_off];
            const Int_t eIndex_s = rowIndex_s[irow-row_off+1];
            for (Int_t index = sIndex_s; index < eIndex_s; index++) {
               rowIndex_new[irow+1]++;
               colIndex_new[nr] = colIndex_s[index]+col_off;
               elements_new[nr] = elements_s[index];
               nr++;
            }
         } else {
            const Int_t off = (irow-row_off)*nCols_source;
            for (Int_t icol = 0; icol < nCols_source; icol++) {
                rowIndex_new[irow+1]++;
                colIndex_new[nr] = icol+col_off;
                elements_new[nr] = elements_s[off+icol];
                nr++;
            }
         }

         const Int_t icol_right = col_off+nCols_source-1;
         if (colIndex_old) {
            Int_t right = TMath::BinarySearch(eIndex_o-sIndex_o,colIndex_old+sIndex_o,icol_right)+sIndex_o;
            while (right < eIndex_o-1 && colIndex_old[right+1] <= icol_right)
               right++;
            right++;

            for (Int_t index = right; index < eIndex_o; index++) {
               rowIndex_new[irow+1]++;
               colIndex_new[nr] = colIndex_old[index];
               elements_new[nr] = elements_old[index];
               nr++;
            }
         }
      } else {
         for (Int_t index = sIndex_o; index < eIndex_o; index++) {
            rowIndex_new[irow+1]++;
            colIndex_new[nr] = colIndex_old[index];
            elements_new[nr] = elements_old[index];
            nr++;
         }
      }
   }

   R__ASSERT(this->fNelems == fRowIndex[this->fNrowIndex-1]);

   if (rowIndex_old) delete [] (Int_t*)    rowIndex_old;
   if (colIndex_old) delete [] (Int_t*)    colIndex_old;
   if (elements_old) delete [] (Element*) elements_old;

   return *this;
}

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

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

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

      if (source.NonZeros() <= 0)
         return *this;
   }

   const Int_t nr_nonzeros = source.NonZeros();

   const Int_t   * const pRowIndex_s = source.GetRowIndexArray();
   const Int_t   * const pColIndex_s = source.GetColIndexArray();
   const Element * const pData_s     = source.GetMatrixArray();

   Int_t   *rownr   = new Int_t  [nr_nonzeros];
   Int_t   *colnr   = new Int_t  [nr_nonzeros];
   Element *pData_t = new Element[nr_nonzeros];

   Int_t ielem = 0;
   for (Int_t irow_s = 0; irow_s < source.GetNrows(); irow_s++) {
      const Int_t sIndex = pRowIndex_s[irow_s];
      const Int_t eIndex = pRowIndex_s[irow_s+1];
      for (Int_t index = sIndex; index < eIndex; index++) {
         if (pData_s[index] != 0.0) {
            rownr[ielem]       = pColIndex_s[index]+this->fRowLwb;
            colnr[ielem]       = irow_s+this->fColLwb;
            pData_t[ielem]     = pData_s[index];
            ielem++;
         }
      }
   }

   R__ASSERT(nr_nonzeros == ielem);

   DoubleLexSort(nr_nonzeros,rownr,colnr,pData_t);
   SetMatrixArray(nr_nonzeros,rownr,colnr,pData_t);

   R__ASSERT(this->fNelems == fRowIndex[this->fNrowIndex-1]);

   if (pData_t) delete [] pData_t;
   if (rownr)   delete [] rownr;
   if (colnr)   delete [] colnr;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<Element>::Zero()
{
   R__ASSERT(this->IsValid());

   if (fElements) { delete [] fElements; fElements = 0; }
   if (fColIndex) { delete [] fColIndex; fColIndex = 0; }
   this->fNelems = 0;
   memset(this->GetRowIndexArray(),0,this->fNrowIndex*sizeof(Int_t));

   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTSparse<Element>::UnitMatrix()
{
  // Make a unit matrix (matrix need not be a square one).

   R__ASSERT(this->IsValid());

   Int_t i;

   Int_t nr_nonzeros = 0;
   for (i = this->fRowLwb; i <= this->fRowLwb+this->fNrows-1; i++)
      for (Int_t j = this->fColLwb; j <= this->fColLwb+this->fNcols-1; j++)
         if (i == j) nr_nonzeros++;

   if (nr_nonzeros != this->fNelems) {
      this->fNelems = nr_nonzeros;
      Int_t *oIp = fColIndex;
      fColIndex = new Int_t[nr_nonzeros];
      if (oIp) delete [] oIp;
      Element *oDp = fElements;
      fElements = new Element[nr_nonzeros];
      if (oDp) delete [] oDp;
   }

   Int_t ielem = 0;
   fRowIndex[0] = 0;
   for (i = this->fRowLwb; i <= this->fRowLwb+this->fNrows-1; i++) {
      for (Int_t j = this->fColLwb; j <= this->fColLwb+this->fNcols-1; j++) {
         if (i == j) {
            const Int_t irow = i-this->fRowLwb;
            fRowIndex[irow+1]  = ielem+1;
            fElements[ielem]   = 1.0;
            fColIndex[ielem++] = j-this->fColLwb;
         }
      }
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparse<Element>::RowNorm() const
{
  // Row matrix norm, MAX{ SUM{ |M(i,j)|, over j}, over i}.
  // The norm is induced by the infinity vector norm.

   R__ASSERT(this->IsValid());

   const Element *       ep = GetMatrixArray();
   const Element * const fp = ep+this->fNelems;
   const Int_t   * const pR = GetRowIndexArray();
         Element norm = 0;

   // Scan the matrix row-after-row
   for (Int_t irow = 0; irow < this->fNrows; irow++) {
      const Int_t sIndex = pR[irow];
      const Int_t eIndex = pR[irow+1];
      Element sum = 0;
      for (Int_t index = sIndex; index < eIndex; index++)
          sum += TMath::Abs(*ep++);
      norm = TMath::Max(norm,sum);
   }

   R__ASSERT(ep == fp);

   return norm;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTSparse<Element>::ColNorm() const
{
  // Column matrix norm, MAX{ SUM{ |M(i,j)|, over i}, over j}.
  // The norm is induced by the 1 vector norm.

   R__ASSERT(this->IsValid());

   const TMatrixTSparse<Element> mt(kTransposed,*this);

   const Element *       ep = mt.GetMatrixArray();
   const Element * const fp = ep+this->fNcols;
         Element norm = 0;

   // Scan the matrix col-after-col
   while (ep < fp) {
      Element sum = 0;
      // Scan a col to compute the sum
      for (Int_t i = 0; i < this->fNrows; i++,ep += this->fNcols)
         sum += TMath::Abs(*ep);
      ep -= this->fNelems-1;         // Point ep to the beginning of the next col
      norm = TMath::Max(norm,sum);
   }

   R__ASSERT(ep == fp);

   return norm;
}

//______________________________________________________________________________
template<class Element>
Element &TMatrixTSparse<Element>::operator()(Int_t rown,Int_t coln)
{
   R__ASSERT(this->IsValid());

   const Int_t arown = rown-this->fRowLwb;
   const Int_t acoln = coln-this->fColLwb;
   if (arown >= this->fNrows || arown < 0) {
      Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
      return fElements[0];
   }
   if (acoln >= this->fNcols || acoln < 0) {
      Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
      return fElements[0];
   }

   Int_t index = -1;
   Int_t sIndex = 0;
   Int_t eIndex = 0;
   if (this->fNrowIndex > 0 && fRowIndex[this->fNrowIndex-1] != 0) {
      sIndex = fRowIndex[arown];
      eIndex = fRowIndex[arown+1];
      index = TMath::BinarySearch(eIndex-sIndex,fColIndex+sIndex,acoln)+sIndex;
   }

   if (index >= sIndex && fColIndex[index] == acoln)
      return fElements[index];
   else {
      Element val = 0.;
      InsertRow(rown,coln,&val,1);
      sIndex = fRowIndex[arown];
      eIndex = fRowIndex[arown+1];
      index = TMath::BinarySearch(eIndex-sIndex,fColIndex+sIndex,acoln)+sIndex;
      if (index >= sIndex && fColIndex[index] == acoln)
         return fElements[index];
      else {
         Error("operator()(Int_t,Int_t","Insert row failed");
         return fElements[0];
      }
   }
}

//______________________________________________________________________________
template <class Element>
Element TMatrixTSparse<Element>::operator()(Int_t rown,Int_t coln) const
{
   R__ASSERT(this->IsValid());
   if (this->fNrowIndex > 0 && this->fRowIndex[this->fNrowIndex-1] == 0) {
      Error("operator()(Int_t,Int_t) const","row/col indices are not set");
      Info("operator()","fNrowIndex = %d fRowIndex[fNrowIndex-1] = %d\n",this->fNrowIndex,this->fRowIndex[this->fNrowIndex-1]);
      return 0.0;
   }
   const Int_t arown = rown-this->fRowLwb;
   const Int_t acoln = coln-this->fColLwb;

   if (arown >= this->fNrows || arown < 0) {
      Error("operator()","Request row(%d) outside matrix range of %d - %d",rown,this->fRowLwb,this->fRowLwb+this->fNrows);
      return 0.0;
   }
   if (acoln >= this->fNcols || acoln < 0) {
      Error("operator()","Request column(%d) outside matrix range of %d - %d",coln,this->fColLwb,this->fColLwb+this->fNcols);
      return 0.0;
   }

   const Int_t sIndex = fRowIndex[arown];
   const Int_t eIndex = fRowIndex[arown+1];
   const Int_t index = (Int_t)TMath::BinarySearch(eIndex-sIndex,fColIndex+sIndex,acoln)+sIndex;
   if (index < sIndex || fColIndex[index] != acoln) return 0.0;
   else                                             return fElements[index];
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::operator=(const TMatrixTSparse<Element> &source)
{
  // Notice that the sparsity of the matrix is NOT changed : its fRowIndex/fColIndex
  // are used !

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

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);

      const Element * const sp = source.GetMatrixArray();
            Element * const tp = this->GetMatrixArray();
      memcpy(tp,sp,this->fNelems*sizeof(Element));
      this->fTol = source.GetTol();
   }
   return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::operator=(const TMatrixT<Element> &source)
{
  // Notice that the sparsity of the matrix is NOT changed : its fRowIndex/fColIndex
  // are used !

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

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> &TMatrixTSparse<Element>::operator=(Element val)
{
  // Assign val to every element of the matrix. Check that the row/col
  // indices are set !

   R__ASSERT(this->IsValid());

   if (fRowIndex[this->fNrowIndex-1] == 0) {
      Error("operator=(Element","row/col indices are not set");
      return *this;
   }

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   return *this;
}

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

   R__ASSERT(this->IsValid());

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

   Int_t   * const pRowIndex = GetRowIndexArray();
   Int_t   * const pColIndex = GetColIndexArray();
   Element * const ep        = GetMatrixArray();

   const Int_t m = this->GetNrows();
   const Int_t n = this->GetNcols();

   // Knuth's algorithm for choosing "length" elements out of nn .
   const Int_t nn     = this->GetNrows()*this->GetNcols();
   const Int_t length = (this->GetNoElements() <= nn) ? this->GetNoElements() : nn;
   Int_t chosen   = 0;
   Int_t icurrent = 0;
   pRowIndex[0] = 0;
   for (Int_t k = 0; k < nn; k++) {
      const Element r = Drand(seed);

      if ((nn-k)*r < length-chosen) {
         pColIndex[chosen] = k%n;
         const Int_t irow  = k/n;

         if (irow > icurrent) {
            for ( ; icurrent < irow; icurrent++)
               pRowIndex[icurrent+1] = chosen;
         }
         ep[chosen] = scale*(Drand(seed)+shift);
         chosen++;
      }
   }
   for ( ; icurrent < m; icurrent++)
      pRowIndex[icurrent+1] = length;

   R__ASSERT(chosen == length);

   return *this;
}

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

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

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

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

   const Int_t n = this->fNcols;

   Int_t   * const pRowIndex = this->GetRowIndexArray();
   Int_t   * const pColIndex = this->GetColIndexArray();
   Element * const ep        = GetMatrixArray();

   // We will always have non-zeros on the diagonal, so there
   // is no randomness there. In fact, choose the (0,0) element now
   pRowIndex[0] = 0;
   pColIndex[0] = 0;
   pRowIndex[1] = 1;
   ep[0]        = 1e-8+scale*(Drand(seed)+shift);

   // Knuth's algorithm for choosing length elements out of nn .
   // nn here is the number of elements in the strict lower triangle.
   const Int_t nn = n*(n-1)/2;

   // length is the number of elements that can be stored, minus the number
   // of elements in the diagonal, which will always be in the matrix.
   //  Int_t length = (this->fNelems-n)/2;
   Int_t length = this->fNelems-n;
   length = (length <= nn) ? length : nn;

   // chosen   : the number of elements that have already been chosen (now 0)
   // nnz      : the number of non-zeros in the matrix (now 1, because the
   //            (0,0) element is already in the matrix.
   // icurrent : the index of the last row whose start has been stored in pRowIndex;

   Int_t chosen   = 0;
   Int_t icurrent = 1;
   Int_t nnz      = 1;
   for (Int_t k = 0; k < nn; k++ ) {
      const Element r = Drand(seed);

      if( (nn-k)*r < length-chosen) {
         // Element k is chosen. What row is it in?
         // In a lower triangular matrix (including a diagonal), it will be in
         // the largest row such that row*(row+1)/2 < k. In other words

         Int_t row = (int) TMath::Floor((-1+TMath::Sqrt(1.0+8.0*k))/2);
         // and its column will be the remainder
         Int_t col = k-row*(row+1)/2;
         // but since we are only filling in the *strict* lower triangle of
         // the matrix, we shift the row by 1
         row++;

         if (row > icurrent) {
            // We have chosen a row beyond the current row.
            // Choose a diagonal element for each intermediate row and fix the
            // data structure.
            for ( ; icurrent < row; icurrent++) {
               // Choose the diagonal
               ep[nnz] = 0.0;
               for (Int_t ll = pRowIndex[icurrent]; ll < nnz; ll++)
                  ep[nnz] += TMath::Abs(ep[ll]);
               ep[nnz] +=  1e-8+scale*(Drand(seed)+shift);
               pColIndex[nnz] = icurrent;

               nnz++;
               pRowIndex[icurrent+1] = nnz;
            }
         } // end if we have chosen a row beyond the current row;
         ep[nnz] = scale*(Drand(seed)+shift);
         pColIndex[nnz] = col;
         // add the value of this element (which occurs symmetrically in the
         // upper triangle) to the appropriate diagonal element
         ep[pRowIndex[col+1]-1] += TMath::Abs(ep[nnz]);

         nnz++; // We have added another element to the matrix
         chosen++; // And finished choosing another element.
      }
   }

   R__ASSERT(chosen == length);

   // and of course, we must choose all remaining diagonal elements .
   for ( ; icurrent < n; icurrent++) {
      // Choose the diagonal
      ep[nnz] = 0.0;
      for(Int_t ll = pRowIndex[icurrent]; ll < nnz; ll++)
         ep[nnz] += TMath::Abs(ep[ll]);
      ep[nnz] += 1e-8+scale*(Drand(seed)+shift);
      pColIndex[nnz] = icurrent;

      nnz++;
      pRowIndex[icurrent+1] = nnz;
   }
   this->fNelems = nnz;

   TMatrixTSparse<Element> tmp(TMatrixTSparse<Element>::kTransposed,*this);
   *this += tmp;

   // make sure to divide the diagonal by 2 becuase the operation
   // *this += tmp; adds the diagonal again
   {
      const Int_t    * const pR = this->GetRowIndexArray();
      const Int_t    * const pC = this->GetColIndexArray();
             Element * const pD = GetMatrixArray();
      for (Int_t irow = 0; irow < this->fNrows+1; irow++) {
         const Int_t sIndex = pR[irow];
         const Int_t eIndex = pR[irow+1];
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = pC[index];
            if (irow == icol)
               pD[index] /= 2.;
         }
      }
   }

   return *this;
}

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator+(const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kPlus,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator+(const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kPlus,source2);
   return target;
}

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

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

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator-(const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kMinus,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator-(const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kMinus,source2);
   return target;
}

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

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

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator*(const TMatrixTSparse<Element> &source1,const TMatrixTSparse<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator*(const TMatrixTSparse<Element> &source1,const TMatrixT<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kMult,source2);
   return target;
}

//______________________________________________________________________________
template<class Element>
TMatrixTSparse<Element> operator*(const TMatrixT<Element> &source1,const TMatrixTSparse<Element> &source2)
{
   TMatrixTSparse<Element> target(source1,TMatrixTSparse<Element>::kMult,source2);
   return target;
}

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

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

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

   target += scalar * source;
   return target;
}

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

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

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

   return target;
}

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

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

   const Element *sp  = source.GetMatrixArray();
         Element *tp  = target.GetMatrixArray();
   const Element *ftp = tp+target.GetNoElements();
   while ( tp < ftp ) {
      if (*sp != 0.0)
         *tp++ /= *sp++;
      else {
         Error("ElementDiv","source element is zero");
         tp++;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
Bool_t AreCompatible(const TMatrixTSparse<Element> &m1,const TMatrixTSparse<Element> &m2,Int_t verbose)
{
   if (!m1.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "matrix 1 not valid");
      return kFALSE;
   }
   if (!m2.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "matrix 2 not valid");
      return kFALSE;
   }

   if (m1.GetNrows()  != m2.GetNrows()  || m1.GetNcols()  != m2.GetNcols() ||
       m1.GetRowLwb() != m2.GetRowLwb() || m1.GetColLwb() != m2.GetColLwb()) {
      if (verbose)
         ::Error("AreCompatible", "matrices 1 and 2 not compatible");
      return kFALSE;
   }

   const Int_t *pR1 = m1.GetRowIndexArray();
   const Int_t *pR2 = m2.GetRowIndexArray();
   const Int_t nRows = m1.GetNrows();
   if (memcmp(pR1,pR2,(nRows+1)*sizeof(Int_t))) {
      if (verbose)
         ::Error("AreCompatible", "matrices 1 and 2 have different rowIndex");
      for (Int_t i = 0; i < nRows+1; i++)
         printf("%d: %d %d\n",i,pR1[i],pR2[i]);
      return kFALSE;
   }
   const Int_t *pD1 = m1.GetColIndexArray();
   const Int_t *pD2 = m2.GetColIndexArray();
   const Int_t nData = m1.GetNoElements();
   if (memcmp(pD1,pD2,nData*sizeof(Int_t))) {
      if (verbose)
         ::Error("AreCompatible", "matrices 1 and 2 have different colIndex");
      for (Int_t i = 0; i < nData; i++)
         printf("%d: %d %d\n",i,pD1[i],pD2[i]);
      return kFALSE;
   }

   return kTRUE;
}

template class TMatrixTSparse<Float_t>;

#ifndef ROOT_TMatrixFSparsefwd
#include "TMatrixFSparsefwd.h"
#endif
#ifndef ROOT_TMatrixFfwd
#include "TMatrixFfwd.h"
#endif

template TMatrixFSparse  operator+    <Float_t>(const TMatrixFSparse &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator+    <Float_t>(const TMatrixFSparse &source1,const TMatrixF       &source2);
template TMatrixFSparse  operator+    <Float_t>(const TMatrixF       &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator+    <Float_t>(const TMatrixFSparse &source ,      Float_t         val    );
template TMatrixFSparse  operator+    <Float_t>(      Float_t         val    ,const TMatrixFSparse &source );
template TMatrixFSparse  operator-    <Float_t>(const TMatrixFSparse &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator-    <Float_t>(const TMatrixFSparse &source1,const TMatrixF       &source2);
template TMatrixFSparse  operator-    <Float_t>(const TMatrixF       &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator-    <Float_t>(const TMatrixFSparse &source ,      Float_t         val    );
template TMatrixFSparse  operator-    <Float_t>(      Float_t         val    ,const TMatrixFSparse &source );
template TMatrixFSparse  operator*    <Float_t>(const TMatrixFSparse &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator*    <Float_t>(const TMatrixFSparse &source1,const TMatrixF       &source2);
template TMatrixFSparse  operator*    <Float_t>(const TMatrixF       &source1,const TMatrixFSparse &source2);
template TMatrixFSparse  operator*    <Float_t>(      Float_t         val    ,const TMatrixFSparse &source );
template TMatrixFSparse  operator*    <Float_t>(const TMatrixFSparse &source,       Float_t         val    );

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

template Bool_t          AreCompatible<Float_t>(const TMatrixFSparse &m1,const TMatrixFSparse &m2,Int_t verbose);

#ifndef ROOT_TMatrixDSparsefwd
#include "TMatrixDSparsefwd.h"
#endif
#ifndef ROOT_TMatrixDfwd
#include "TMatrixDfwd.h"
#endif

template class TMatrixTSparse<Double_t>;

template TMatrixDSparse  operator+    <Double_t>(const TMatrixDSparse &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator+    <Double_t>(const TMatrixDSparse &source1,const TMatrixD       &source2);
template TMatrixDSparse  operator+    <Double_t>(const TMatrixD       &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator+    <Double_t>(const TMatrixDSparse &source ,      Double_t        val    );
template TMatrixDSparse  operator+    <Double_t>(      Double_t        val    ,const TMatrixDSparse &source );
template TMatrixDSparse  operator-    <Double_t>(const TMatrixDSparse &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator-    <Double_t>(const TMatrixDSparse &source1,const TMatrixD       &source2);
template TMatrixDSparse  operator-    <Double_t>(const TMatrixD       &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator-    <Double_t>(const TMatrixDSparse &source ,      Double_t        val    );
template TMatrixDSparse  operator-    <Double_t>(      Double_t        val    ,const TMatrixDSparse &source );
template TMatrixDSparse  operator*    <Double_t>(const TMatrixDSparse &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator*    <Double_t>(const TMatrixDSparse &source1,const TMatrixD       &source2);
template TMatrixDSparse  operator*    <Double_t>(const TMatrixD       &source1,const TMatrixDSparse &source2);
template TMatrixDSparse  operator*    <Double_t>(      Double_t        val    ,const TMatrixDSparse &source );
template TMatrixDSparse  operator*    <Double_t>(const TMatrixDSparse &source,       Double_t        val    );

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

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