// @(#)root/matrix:$Id: TMatrixTSparse.cxx 30125 2009-09-14 05:03:58Z 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> TMatrixTSparse<Element>::TMatrixTSparse(const TMatrixTSparse<Element> &a,EMatrixCreatorsOp2 op,const TMatrixT<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> TMatrixTSparse<Element>::TMatrixTSparse(const TMatrixT<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++; } const 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 indexc_r = 0; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexa = pRowIndexa[irowc]; const Int_t eIndexa = pRowIndexa[irowc+1]; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { 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 (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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(); const 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; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexa = pRowIndexa[irowc]; const Int_t eIndexa = pRowIndexa[irowc+1]; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { 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 (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1]= indexc_r; } 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++; } const 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; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t off = irowc*a.GetNcols(); for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { 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 (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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; for (Int_t irowc = 0; irowc < this->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 indexa = sIndexa; Int_t indexb = sIndexb; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { 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 (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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) { 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 Int_t * const pRowIndexa = a.GetRowIndexArray(); const Int_t * const pColIndexa = a.GetColIndexArray(); const Element * const pDataa = a.GetMatrixArray(); const Element * const pDatab = b.GetMatrixArray(); Element * const pDatac = this->GetMatrixArray(); Int_t indexc_r = 0; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexa = pRowIndexa[irowc]; const Int_t eIndexa = pRowIndexa[irowc+1]; const Int_t off = irowc*this->GetNcols(); Int_t indexa = sIndexa; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { Element sum = pDatab[off+icolc]; while (indexa < eIndexa && pColIndexa[indexa] <= icolc) { if (icolc == pColIndexa[indexa]) { sum += pDataa[indexa]; break; } indexa++; } if (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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; for (Int_t irowc = 0; irowc < this->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 indexa = sIndexa; Int_t indexb = sIndexb; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { 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 (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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) { 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 Int_t * const pRowIndexa = a.GetRowIndexArray(); const Int_t * const pColIndexa = a.GetColIndexArray(); const Element * const pDataa = a.GetMatrixArray(); const Element * const pDatab = b.GetMatrixArray(); Element * const pDatac = this->GetMatrixArray(); Int_t indexc_r = 0; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexa = pRowIndexa[irowc]; const Int_t eIndexa = pRowIndexa[irowc+1]; const Int_t off = irowc*this->GetNcols(); Int_t indexa = sIndexa; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { Element sum = -pDatab[off+icolc]; while (indexa < eIndexa && pColIndexa[indexa] <= icolc) { if (icolc == pColIndexa[indexa]) { sum += pDataa[indexa]; break; } indexa++; } if (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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) { 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 Int_t * const pRowIndexb = b.GetRowIndexArray(); const Int_t * const pColIndexb = b.GetColIndexArray(); const Element * const pDataa = a.GetMatrixArray(); const Element * const pDatab = b.GetMatrixArray(); Element * const pDatac = this->GetMatrixArray(); Int_t indexc_r = 0; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexb = pRowIndexb[irowc]; const Int_t eIndexb = pRowIndexb[irowc+1]; const Int_t off = irowc*this->GetNcols(); Int_t indexb = sIndexb; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { Element sum = pDataa[off+icolc]; while (indexb < eIndexb && pColIndexb[indexb] <= icolc) { if (icolc == pColIndexb[indexb]) { sum -= pDatab[indexb]; break; } indexb++; } if (sum != 0.0) { pColIndexc[indexc_r] = icolc; pDatac[indexc_r] = sum; indexc_r++; } } pRowIndexc[irowc+1] = indexc_r; } 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 (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(); // Count first the number of non-zero slots that are needed Int_t nc = 0; for (Int_t 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) { const Int_t icola = (eIndexa > 0) ? pColIndexa[eIndexa-1] : -1; if (pColIndexb[indexb++] > icola) nc++; } } // Allocate the necessary space in fRowIndex and fColIndex if (this->NonZeros() != nc) SetSparseIndex(nc); Int_t * const pRowIndexc = this->GetRowIndexArray(); Int_t * const pColIndexc = this->GetColIndexArray(); nc = 0; pRowIndexc[0] = 0; for (Int_t 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) { const Int_t icola = (eIndexa > 0) ? pColIndexa[eIndexa-1] : -1; if (pColIndexb[indexb++] > icola) pColIndexc[nc++] = pColIndexb[indexb-1]; } pRowIndexc[irowc+1] = nc; } return *this; } //______________________________________________________________________________ template<class Element> TMatrixTSparse<Element> &TMatrixTSparse<Element>::SetSparseIndexAB(const TMatrixT<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 Element * const pDataa = a.GetMatrixArray(); const Int_t * const pRowIndexb = b.GetRowIndexArray(); const Int_t * const pColIndexb = b.GetColIndexArray(); // Count first the number of non-zero slots that are needed Int_t nc = a.NonZeros(); for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexb = pRowIndexb[irowc]; const Int_t eIndexb = pRowIndexb[irowc+1]; const Int_t off = irowc*this->GetNcols(); Int_t indexb = sIndexb; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { if (pDataa[off+icolc] != 0.0 || pColIndexb[indexb] > icolc) continue; for (; indexb < eIndexb; indexb++) { if (pColIndexb[indexb] >= icolc) { if (pColIndexb[indexb] == icolc) { nc++; indexb++; } break; } } } } // Allocate thre necessary space in fRowIndex and fColIndex if (this->NonZeros() != nc) SetSparseIndex(nc); Int_t * const pRowIndexc = this->GetRowIndexArray(); Int_t * const pColIndexc = this->GetColIndexArray(); nc = 0; pRowIndexc[0] = 0; for (Int_t irowc = 0; irowc < this->GetNrows(); irowc++) { const Int_t sIndexb = pRowIndexb[irowc]; const Int_t eIndexb = pRowIndexb[irowc+1]; const Int_t off = irowc*this->GetNcols(); Int_t indexb = sIndexb; for (Int_t icolc = 0; icolc < this->GetNcols(); icolc++) { if (pDataa[off+icolc] != 0.0) pColIndexc[nc++] = icolc; else if (pColIndexb[indexb] <= icolc) { for (; indexb < eIndexb; indexb++) { if (pColIndexb[indexb] >= icolc) { if (pColIndexb[indexb] == icolc) pColIndexc[nc++] = pColIndexb[indexb++]; break; } } } } 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++) { 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 Element> void TMatrixTSparse<Element>::Streamer(TBuffer &R__b) { // Stream an object of class TMatrixTSparse. if (R__b.IsReading()) { UInt_t R__s, R__c; Version_t R__v = R__b.ReadVersion(&R__s, &R__c); Clear(); R__b.ReadClassBuffer(TMatrixTSparse<Element>::Class(),this,R__v,R__s,R__c); if (this->fNelems < 0) this->Invalidate(); } else { R__b.WriteClassBuffer(TMatrixTSparse<Element>::Class(),this); } } 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
TMatrixTSparse.cxx:2713
TMatrixTSparse.cxx:2714
TMatrixTSparse.cxx:2715
TMatrixTSparse.cxx:2716
TMatrixTSparse.cxx:2717
TMatrixTSparse.cxx:2718
TMatrixTSparse.cxx:2719
TMatrixTSparse.cxx:2720
TMatrixTSparse.cxx:2721
TMatrixTSparse.cxx:2722
TMatrixTSparse.cxx:2723
TMatrixTSparse.cxx:2724
TMatrixTSparse.cxx:2725
TMatrixTSparse.cxx:2726
TMatrixTSparse.cxx:2727
TMatrixTSparse.cxx:2728
TMatrixTSparse.cxx:2729
TMatrixTSparse.cxx:2730
TMatrixTSparse.cxx:2731
TMatrixTSparse.cxx:2732
TMatrixTSparse.cxx:2733
TMatrixTSparse.cxx:2734
TMatrixTSparse.cxx:2735
TMatrixTSparse.cxx:2736
TMatrixTSparse.cxx:2737
TMatrixTSparse.cxx:2738
TMatrixTSparse.cxx:2739
TMatrixTSparse.cxx:2740
TMatrixTSparse.cxx:2741
TMatrixTSparse.cxx:2742
TMatrixTSparse.cxx:2743
TMatrixTSparse.cxx:2744
TMatrixTSparse.cxx:2745
TMatrixTSparse.cxx:2746
TMatrixTSparse.cxx:2747
TMatrixTSparse.cxx:2748
TMatrixTSparse.cxx:2749
TMatrixTSparse.cxx:2750
TMatrixTSparse.cxx:2751
TMatrixTSparse.cxx:2752
TMatrixTSparse.cxx:2753
TMatrixTSparse.cxx:2754
TMatrixTSparse.cxx:2755
TMatrixTSparse.cxx:2756
TMatrixTSparse.cxx:2757
TMatrixTSparse.cxx:2758
TMatrixTSparse.cxx:2759
TMatrixTSparse.cxx:2760
TMatrixTSparse.cxx:2761
TMatrixTSparse.cxx:2762
TMatrixTSparse.cxx:2763
TMatrixTSparse.cxx:2764
TMatrixTSparse.cxx:2765
TMatrixTSparse.cxx:2766
TMatrixTSparse.cxx:2767
TMatrixTSparse.cxx:2768
TMatrixTSparse.cxx:2769
TMatrixTSparse.cxx:2770
TMatrixTSparse.cxx:2771
TMatrixTSparse.cxx:2772
TMatrixTSparse.cxx:2773
TMatrixTSparse.cxx:2774
TMatrixTSparse.cxx:2775
TMatrixTSparse.cxx:2776
TMatrixTSparse.cxx:2777
TMatrixTSparse.cxx:2778
TMatrixTSparse.cxx:2779
TMatrixTSparse.cxx:2780
TMatrixTSparse.cxx:2781
TMatrixTSparse.cxx:2782
TMatrixTSparse.cxx:2783
TMatrixTSparse.cxx:2784
TMatrixTSparse.cxx:2785
TMatrixTSparse.cxx:2786
TMatrixTSparse.cxx:2787
TMatrixTSparse.cxx:2788
TMatrixTSparse.cxx:2789
TMatrixTSparse.cxx:2790
TMatrixTSparse.cxx:2791
TMatrixTSparse.cxx:2792
TMatrixTSparse.cxx:2793
TMatrixTSparse.cxx:2794
TMatrixTSparse.cxx:2795
TMatrixTSparse.cxx:2796
TMatrixTSparse.cxx:2797
TMatrixTSparse.cxx:2798
TMatrixTSparse.cxx:2799
TMatrixTSparse.cxx:2800
TMatrixTSparse.cxx:2801
TMatrixTSparse.cxx:2802
TMatrixTSparse.cxx:2803
TMatrixTSparse.cxx:2804
TMatrixTSparse.cxx:2805
TMatrixTSparse.cxx:2806
TMatrixTSparse.cxx:2807
TMatrixTSparse.cxx:2808
TMatrixTSparse.cxx:2809
TMatrixTSparse.cxx:2810
TMatrixTSparse.cxx:2811
TMatrixTSparse.cxx:2812
TMatrixTSparse.cxx:2813
TMatrixTSparse.cxx:2814
TMatrixTSparse.cxx:2815
TMatrixTSparse.cxx:2816
TMatrixTSparse.cxx:2817
TMatrixTSparse.cxx:2818