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

/*************************************************************************
*                                                                       *
* For the licensing terms see \$ROOTSYS/LICENSE.                         *
* For the list of contributors see \$ROOTSYS/README/CREDITS.             *
*************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Linear Algebra Package                                               //
// ----------------------                                               //
//                                                                      //
// The present package implements all the basic algorithms dealing      //
// with vectors, matrices, matrix columns, rows, diagonals, etc.        //
// In addition eigen-Vector analysis and several matrix decomposition   //
// have been added (LU,QRH,Cholesky,Bunch-Kaufman and SVD) .            //
// The decompositions are used in matrix inversion, equation solving.   //
//                                                                      //
// For a dense matrix, elements are arranged in memory in a ROW-wise    //
// fashion . For (n x m) matrices where n*m <=kSizeMax (=25 currently)  //
// storage space is available on the stack, thus avoiding expensive     //
// allocation/deallocation of heap space . However, this introduces of  //
// course kSizeMax overhead for each matrix object . If this is an      //
// issue recompile with a new appropriate value (>=0) for kSizeMax      //
//                                                                      //
// Sparse matrices are also stored in row-wise fashion but additional   //
// row/column information is stored, see TMatrixTSparse source for      //
//                                                                      //
// Another way to assign and store matrix data is through Use           //
// see for instance stressLinear.cxx file .                             //
//                                                                      //
// Unless otherwise specified, matrix and vector indices always start   //
// with 0, spanning up to the specified limit-1. However, there are     //
// constructors to which one can specify aribtrary lower and upper      //
// bounds, e.g. TMatrixD m(1,10,1,5) defines a matrix that ranges       //
// from 1..10, 1..5 (a(1,1)..a(10,5)).                                  //
//                                                                      //
// The present package provides all facilities to completely AVOID      //
// returning matrices. Use "TMatrixD A(TMatrixD::kTransposed,B);"       //
// and other fancy constructors as much as possible. If one really needs//
// to return a matrix, return a TMatrixTLazy object instead. The        //
// conversion is completely transparent to the end user, e.g.           //
// "TMatrixT m = THaarMatrixT(5);" and _is_ efficient.                  //
//                                                                      //
// Since TMatrixT et al. are fully integrated in ROOT, they of course   //
// can be stored in a ROOT database.                                    //
//                                                                      //
// For usage examples see \$ROOTSYS/test/stressLinear.cxx                //
//                                                                      //
// Acknowledgements                                                     //
// ----------------                                                     //
// 1. Oleg E. Kiselyov                                                  //
//  First implementations were based on the his code . We have diverged //
//  quite a bit since then but the ideas/code for lazy matrix and       //
//  "nested function" are 100% his .                                    //
//  You can see him and his code in action at http://okmij.org/ftp      //
// 2. Chris R. Birchenhall,                                             //
//  We adapted his idea of the implementation for the decomposition     //
//  classes instead of our messy installation of matrix inversion       //
//  His installation of matrix condition number, using an iterative     //
//  scheme using the Hage algorithm is worth looking at !               //
//  Chris has a nice writeup (matdoc.ps) on his matrix classes at       //
//   ftp://ftp.mcc.ac.uk/pub/matclass/                                  //
// 3. Mark Fischler and Steven Haywood of CLHEP                         //
//  They did the slave labor of spelling out all sub-determinants       //
//   for Cramer inversion  of (4x4),(5x5) and (6x6) matrices            //
//  The stack storage for small matrices was also taken from them       //
// 4. Roldan Pozo of TNT (http://math.nist.gov/tnt/)                    //
//  He converted the EISPACK routines for the eigen-vector analysis to  //
//  C++ . We started with his implementation                            //
// 5. Siegmund Brandt (http://siux00.physik.uni-siegen.de/~brandt/datan //
//  We adapted his (very-well) documented SVD routines                  //
//                                                                      //
// How to efficiently use this package                                  //
// -----------------------------------                                  //
//                                                                      //
// 1. Never return complex objects (matrices or vectors)                //
//    Danger: For example, when the following snippet:                  //
//        TMatrixD foo(int n)                                           //
//        {                                                             //
//           TMatrixD foom(n,n); fill_in(foom); return foom;            //
//        }                                                             //
//        TMatrixD m = foo(5);                                          //
//    runs, it constructs matrix foo:foom, copies it onto stack as a    //
//    return value and destroys foo:foom. Return value (a matrix)       //
//    from foo() is then copied over to m (via a copy constructor),     //
//    and the return value is destroyed. So, the matrix constructor is  //
//    called 3 times and the destructor 2 times. For big matrices,      //
//    the cost of multiple constructing/copying/destroying of objects   //
//    may be very large. *Some* optimized compilers can cut down on 1   //
//    copying/destroying, but still it leaves at least two calls to     //
//    the constructor. Note, TMatrixDLazy (see below) can construct     //
//    TMatrixD m "inplace", with only a _single_ call to the            //
//    constructor.                                                      //
//                                                                      //
// 2. Use "two-address instructions"                                    //
//        "void TMatrixD::operator += (const TMatrixD &B);"             //
//    as much as possible.                                              //
//    That is, to add two matrices, it's much more efficient to write   //
//        A += B;                                                       //
//    than                                                              //
//        TMatrixD C = A + B;                                           //
//    (if both operand should be preserved,                             //
//        TMatrixD C = A; C += B;                                       //
//    is still better).                                                 //
//                                                                      //
// 3. Use glorified constructors when returning of an object seems      //
//    inevitable:                                                       //
//        "TMatrixD A(TMatrixD::kTransposed,B);"                        //
//        "TMatrixD C(A,TMatrixD::kTransposeMult,B);"                   //
//                                                                      //
//    like in the following snippet (from \$ROOTSYS/test/vmatrix.cxx)    //
//    that verifies that for an orthogonal matrix T, T'T = TT' = E.     //
//                                                                      //
//    TMatrixD haar = THaarMatrixD(5);                                  //
//    TMatrixD unit(TMatrixD::kUnit,haar);                              //
//    TMatrixD haar_t(TMatrixD::kTransposed,haar);                      //
//    TMatrixD hth(haar,TMatrixD::kTransposeMult,haar);                 //
//    TMatrixD hht(haar,TMatrixD::kMult,haar_t);                        //
//    TMatrixD hht1 = haar; hht1 *= haar_t;                             //
//    VerifyMatrixIdentity(unit,hth);                                   //
//    VerifyMatrixIdentity(unit,hht);                                   //
//    VerifyMatrixIdentity(unit,hht1);                                  //
//                                                                      //
// 4. Accessing row/col/diagonal of a matrix without much fuss          //
//    (and without moving a lot of stuff around):                       //
//                                                                      //
//        TMatrixD m(n,n); TVectorD v(n); TMatrixDDiag(m) += 4;         //
//        v = TMatrixDRow(m,0);                                         //
//        TMatrixDColumn m1(m,1); m1(2) = 3; // the same as m(2,1)=3;   //
//    Note, constructing of, say, TMatrixDDiag does *not* involve any   //
//    copying of any elements of the source matrix.                     //
//                                                                      //
// 5. It's possible (and encouraged) to use "nested" functions          //
//    For example, creating of a Hilbert matrix can be done as follows: //
//                                                                      //
//    void foo(const TMatrixD &m)                                       //
//    {                                                                 //
//       TMatrixD m1(TMatrixD::kZero,m);                                //
//       struct MakeHilbert : public TElementPosActionD {               //
//          void Operation(Double_t &element)                           //
//             { element = 1./(fI+fJ-1); }                              //
//       };                                                             //
//       m1.Apply(MakeHilbert());                                       //
//    }                                                                 //
//                                                                      //
//    of course, using a special method THilbertMatrixD() is            //
//    still more optimal, but not by a whole lot. And that's right,     //
//    class MakeHilbert is declared *within* a function and local to    //
//    that function. It means one can define another MakeHilbert class  //
//    (within another function or outside of any function, that is, in  //
//    the global scope), and it still will be OK. Note, this currently  //
//    is not yet supported by the interpreter CINT.                     //
//                                                                      //
//    Another example is applying of a simple function to each matrix   //
//    element:                                                          //
//                                                                      //
//    void foo(TMatrixD &m,TMatrixD &m1)                                //
//    {                                                                 //
//       typedef  double (*dfunc_t)(double);                            //
//       class ApplyFunction : public TElementActionD {                 //
//          dfunc_t fFunc;                                              //
//          void Operation(Double_t &element)                           //
//               { element=fFunc(element); }                            //
//        public:                                                       //
//          ApplyFunction(dfunc_t func):fFunc(func) {}                  //
//       };                                                             //
//       ApplyFunction x(TMath::Sin);                                   //
//       m.Apply(x);                                                    //
//    }                                                                 //
//                                                                      //
//    Validation code \$ROOTSYS/test/vmatrix.cxx and vvector.cxx contain //
//    a few more examples of that kind.                                 //
//                                                                      //
// 6. Lazy matrices: instead of returning an object return a "recipe"   //
//    how to make it. The full matrix would be rolled out only when     //
//    and where it's needed:                                            //
//       TMatrixD haar = THaarMatrixD(5);                               //
//    THaarMatrixD() is a *class*, not a simple function. However       //
//    similar this looks to a returning of an object (see note #1       //
//    above), it's dramatically different. THaarMatrixD() constructs a  //
//    TMatrixDLazy, an object of just a few bytes long. A special       //
//    "TMatrixD(const TMatrixDLazy &recipe)" constructor follows the    //
//    recipe and makes the matrix haar() right in place. No matrix      //
//    element is moved whatsoever!                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTBase                                                         //
//                                                                      //
// Template of base class in the linear algebra package                 //
//                                                                      //
//  matrix properties are stored here, however the data storage is part //
//  of the derived classes                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMatrixTBase.h"
#include "TVectorT.h"
#include "TROOT.h"
#include "TClass.h"
#include "TMath.h"
#include <limits.h>

Int_t gMatrixCheck = 1;

templateClassImp(TMatrixTBase)

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<Element>::DoubleLexSort(Int_t n,Int_t *first,Int_t *second,Element *data)
{
// Lexical sort on array data using indices first and second

const int incs[] = {1,5,19,41,109,209,505,929,2161,3905,8929,16001,INT_MAX};

Int_t kinc = 0;
while (incs[kinc] <= n/2)
kinc++;
kinc -= 1;

// incs[kinc] is the greatest value in the sequence that is also <= n/2.
// If n == {0,1}, kinc == -1 and so no sort will take place.

for( ; kinc >= 0; kinc--) {
const Int_t inc = incs[kinc];

for (Int_t k = inc; k < n; k++) {
const Element tmp = data[k];
const Int_t fi = first [k];
const Int_t se = second[k];
Int_t j;
for (j = k; j >= inc; j -= inc) {
if ( fi < first[j-inc] || (fi == first[j-inc] && se < second[j-inc]) ) {
data  [j] = data  [j-inc];
first [j] = first [j-inc];
second[j] = second[j-inc];
} else
break;
}
data  [j] = tmp;
first [j] = fi;
second[j] = se;
}
}
}

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<Element>::IndexedLexSort(Int_t n,Int_t *first,Int_t swapFirst,
Int_t *second,Int_t swapSecond,Int_t *index)
{
// Lexical sort on array data using indices first and second

const int incs[] = {1,5,19,41,109,209,505,929,2161,3905,8929,16001,INT_MAX};

Int_t kinc = 0;
while (incs[kinc] <= n/2)
kinc++;
kinc -= 1;

// incs[kinc] is the greatest value in the sequence that is also less
// than n/2.

for( ; kinc >= 0; kinc--) {
const Int_t inc = incs[kinc];

if ( !swapFirst && !swapSecond ) {
for (Int_t k = inc; k < n; k++) {
// loop over all subarrays defined by the current increment
const Int_t ktemp = index[k];
const Int_t fi = first [ktemp];
const Int_t se = second[ktemp];
// Insert element k into the sorted subarray
Int_t j;
for (j = k; j >= inc; j -= inc) {
// Loop over the elements in the current subarray
if (fi < first[index[j-inc]] || (fi == first[index[j-inc]] && se < second[index[j-inc]])) {
// Swap elements j and j - inc, implicitly use the fact
// that ktemp hold element j to avoid having to assign to
// element j-inc
index[j] = index[j-inc];
} else {
// There are no more elements in this sorted subarray which
// are less than element j
break;
}
} // End loop over the elements in the current subarray
// Move index[j] out of temporary storage
index[j] = ktemp;
// The element has been inserted into the subarray.
} // End loop over all subarrays defined by the current increment
} else if ( swapSecond && !swapFirst ) {
for (Int_t k = inc; k < n; k++) {
const Int_t ktemp = index[k];
const Int_t fi = first [ktemp];
const Int_t se = second[k];
Int_t j;
for (j = k; j >= inc; j -= inc) {
if (fi < first[index[j-inc]] || (fi == first[index[j-inc]] && se < second[j-inc])) {
index [j] = index[j-inc];
second[j] = second[j-inc];
} else {
break;
}
}
index[j]  = ktemp;
second[j] = se;
}
} else if (swapFirst  && !swapSecond) {
for (Int_t k = inc; k < n; k++ ) {
const Int_t ktemp = index[k];
const Int_t fi = first[k];
const Int_t se = second[ktemp];
Int_t j;
for (j = k; j >= inc; j -= inc) {
if ( fi < first[j-inc] || (fi == first[j-inc] && se < second[ index[j-inc]])) {
index[j] = index[j-inc];
first[j] = first[j-inc];
} else {
break;
}
}
index[j] = ktemp;
first[j] = fi;
}
} else { // Swap both
for (Int_t k = inc; k < n; k++ ) {
const Int_t ktemp = index[k];
const Int_t fi = first [k];
const Int_t se = second[k];
Int_t j;
for (j = k; j >= inc; j -= inc) {
if ( fi < first[j-inc] || (fi == first[j-inc] && se < second[j-inc])) {
index [j] = index [j-inc];
first [j] = first [j-inc];
second[j] = second[j-inc];
} else {
break;
}
}
index[j]  = ktemp;
first[j]  = fi;
second[j] = se;
}
}
}
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::SetMatrixArray(const Element *data,Option_t *option)
{
// Copy array data to matrix . It is assumed that array is of size >= fNelems
// (=)))) fNrows*fNcols
// option indicates how the data is stored in the array:
// option =
//          'F'   : column major (Fortran) m[i][j] = array[i+j*fNrows]
//          else  : row major    (C)       m[i][j] = array[i*fNcols+j] (default)

R__ASSERT(IsValid());

TString opt = option;
opt.ToUpper();

Element *elem = GetMatrixArray();
if (opt.Contains("F")) {
for (Int_t irow = 0; irow < fNrows; irow++) {
const Int_t off1 = irow*fNcols;
Int_t off2 = 0;
for (Int_t icol = 0; icol < fNcols; icol++) {
elem[off1+icol] = data[off2+irow];
off2 += fNrows;
}
}
}
else
memcpy(elem,data,fNelems*sizeof(Element));

return *this;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::IsSymmetric() const
{
// Check whether matrix is symmetric

R__ASSERT(IsValid());

if ((fNrows != fNcols) || (fRowLwb != fColLwb))
return kFALSE;

const Element * const elem = GetMatrixArray();
for (Int_t irow = 0; irow < fNrows; irow++) {
const Int_t rowOff = irow*fNcols;
Int_t colOff = 0;
for (Int_t icol = 0; icol < irow; icol++) {
if (elem[rowOff+icol] != elem[colOff+irow])
return kFALSE;
colOff += fNrows;
}
}
return kTRUE;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<Element>::GetMatrix2Array(Element *data,Option_t *option) const
{
// Copy matrix data to array . It is assumed that array is of size >= fNelems
// (=)))) fNrows*fNcols
// option indicates how the data is stored in the array:
// option =
//          'F'   : column major (Fortran) array[i+j*fNrows] = m[i][j]
//          else  : row major    (C)       array[i*fNcols+j] = m[i][j] (default)

R__ASSERT(IsValid());

TString opt = option;
opt.ToUpper();

const Element * const elem = GetMatrixArray();
if (opt.Contains("F")) {
for (Int_t irow = 0; irow < fNrows; irow++) {
const Int_t off1 = irow*fNcols;
Int_t off2 = 0;
for (Int_t icol = 0; icol < fNcols; icol++) {
data[off2+irow] = elem[off1+icol];
off2 += fNrows;
}
}
}
else
memcpy(data,elem,fNelems*sizeof(Element));
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::InsertRow(Int_t rown,Int_t coln,const Element *v,Int_t n)
{
// Copy n elements from array v to row rown starting at column coln

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

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

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

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

const Int_t off = arown*fNcols+acoln;
Element * const elem = GetMatrixArray()+off;
memcpy(elem,v,nr*sizeof(Element));

return *this;
}

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<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-fRowLwb;
const Int_t acoln = coln-fColLwb;
const Int_t nr = (n > 0) ? n : fNcols;

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

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

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

const Int_t off = arown*fNcols+acoln;
const Element * const elem = GetMatrixArray()+off;
memcpy(v,elem,nr*sizeof(Element));
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Shift(Int_t row_shift,Int_t col_shift)
{
// Shift the row index by adding row_shift and the column index by adding
// col_shift, respectively. So [rowLwb..rowUpb][colLwb..colUpb] becomes
// [rowLwb+row_shift..rowUpb+row_shift][colLwb+col_shift..colUpb+col_shift]

fRowLwb += row_shift;
fColLwb += col_shift;

return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Zero()
{
// Set matrix elements to zero

R__ASSERT(IsValid());
memset(this->GetMatrixArray(),0,fNelems*sizeof(Element));

return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Abs()
{
// Take an absolute value of a matrix, i.e. apply Abs() to each element.

R__ASSERT(IsValid());

Element *ep = this->GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp) {
*ep = TMath::Abs(*ep);
ep++;
}

return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Sqr()
{
// Square each element of the matrix.

R__ASSERT(IsValid());

Element *ep = this->GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp) {
*ep = (*ep) * (*ep);
ep++;
}

return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Sqrt()
{
// Take square root of all elements.

R__ASSERT(IsValid());

Element *ep = this->GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp) {
*ep = TMath::Sqrt(*ep);
ep++;
}

return *this;
}

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

R__ASSERT(IsValid());

Element *ep = this->GetMatrixArray();
memset(ep,0,fNelems*sizeof(Element));
for (Int_t i = fRowLwb; i <= fRowLwb+fNrows-1; i++)
for (Int_t j = fColLwb; j <= fColLwb+fNcols-1; j++)
*ep++ = (i==j ? 1.0 : 0.0);

return *this;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::NormByDiag(const TVectorT<Element> &v,Option_t *option)
{
// option:
// "D"   :  b(i,j) = a(i,j)/sqrt(abs*(v(i)*v(j)))  (default)
// else  :  b(i,j) = a(i,j)*sqrt(abs*(v(i)*v(j)))  (default)

R__ASSERT(IsValid());
R__ASSERT(v.IsValid());

if (gMatrixCheck) {
const Int_t nMax = TMath::Max(fNrows,fNcols);
if (v.GetNoElements() < nMax) {
Error("NormByDiag","vector shorter than matrix diagonal");
return *this;
}
}

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

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

if (divide) {
for (Int_t irow = 0; irow < fNrows; irow++) {
if (pV[irow] != 0.0) {
for (Int_t icol = 0; icol < fNcols; icol++) {
if (pV[icol] != 0.0) {
const Element val = TMath::Sqrt(TMath::Abs(pV[irow]*pV[icol]));
*mp++ /= val;
} else {
Error("NormbyDiag","vector element %d is zero",icol);
mp++;
}
}
} else {
Error("NormbyDiag","vector element %d is zero",irow);
mp += fNcols;
}
}
} else {
for (Int_t irow = 0; irow < fNrows; irow++) {
for (Int_t icol = 0; icol < fNcols; icol++) {
const Element val = TMath::Sqrt(TMath::Abs(pV[irow]*pV[icol]));
*mp++ *= val;
}
}
}

return *this;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTBase<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(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
Element norm = 0;

// Scan the matrix row-after-row
while (ep < fp) {
Element sum = 0;
// Scan a row to compute the sum
for (Int_t j = 0; j < fNcols; j++)
sum += TMath::Abs(*ep++);
norm = TMath::Max(norm,sum);
}

R__ASSERT(ep == fp);

return norm;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTBase<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(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+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 < fNrows; i++,ep += fNcols)
sum += TMath::Abs(*ep);
ep -= 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 TMatrixTBase<Element>::E2Norm() const
{
// Square of the Euclidian norm, SUM{ m(i,j)^2 }.

R__ASSERT(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
Element sum = 0;

for ( ; ep < fp; ep++)
sum += (*ep) * (*ep);

return sum;
}

//______________________________________________________________________________
template<class Element>
Int_t TMatrixTBase<Element>::NonZeros() const
{
// Compute the number of elements != 0.0

R__ASSERT(IsValid());

Int_t nr_nonzeros = 0;
const Element *ep = this->GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp)
if (*ep++ != 0.0) nr_nonzeros++;

return nr_nonzeros;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTBase<Element>::Sum() const
{
// Compute sum of elements

R__ASSERT(IsValid());

Element sum = 0.0;
const Element *ep = this->GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp)
sum += *ep++;

return sum;
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTBase<Element>::Min() const
{
// return minimum matrix element value

R__ASSERT(IsValid());

const Element * const ep = this->GetMatrixArray();
const Int_t index = TMath::LocMin(fNelems,ep);
return ep[index];
}

//______________________________________________________________________________
template<class Element>
Element TMatrixTBase<Element>::Max() const
{
// return maximum vector element value

R__ASSERT(IsValid());

const Element * const ep = this->GetMatrixArray();
const Int_t index = TMath::LocMax(fNelems,ep);
return ep[index];
}

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<Element>::Draw(Option_t *option)
{
// Draw this matrix
// The histogram is named "TMatrixT" by default and no title

gROOT->ProcessLine(Form("THistPainter::PaintSpecialObjects((TObject*)0x%lx,\"%s\");",
(ULong_t)this, option));
}

//______________________________________________________________________________
template<class Element>
void TMatrixTBase<Element>::Print(Option_t *option) const
{
// Print the matrix as a table of elements.
// By default the format "%11.4g" is used to print one element.
// One can specify an alternative format with eg
//  option ="f=  %6.2f  "

if (!IsValid()) {
Error("Print","Matrix is invalid");
return;
}

//build format
const char *format = "%11.4g ";
if (option) {
const char *f = strstr(option,"f=");
if (f) format = f+2;
}
char topbar[100];
snprintf(topbar,100,format,123.456789);
Int_t nch = strlen(topbar)+1;
if (nch > 18) nch = 18;
char ftopbar[20];
for (Int_t i = 0; i < nch; i++) ftopbar[i] = ' ';
Int_t nk = 1 + Int_t(TMath::Log10(fNcols));
snprintf(ftopbar+nch/2,20-nch/2,"%s%dd","%",nk);
Int_t nch2 = strlen(ftopbar);
for (Int_t i = nch2; i < nch; i++) ftopbar[i] = ' ';
ftopbar[nch] = '|';
ftopbar[nch+1] = 0;

printf("\n%dx%d matrix is as follows",fNrows,fNcols);

Int_t cols_per_sheet = 5;
if (nch <= 8) cols_per_sheet =10;
const Int_t ncols  = fNcols;
const Int_t nrows  = fNrows;
const Int_t collwb = fColLwb;
const Int_t rowlwb = fRowLwb;
nk = 5+nch*TMath::Min(cols_per_sheet,fNcols);
for (Int_t i = 0; i < nk; i++) topbar[i] = '-';
topbar[nk] = 0;
for (Int_t sheet_counter = 1; sheet_counter <= ncols; sheet_counter += cols_per_sheet) {
printf("\n\n     |");
for (Int_t j = sheet_counter; j < sheet_counter+cols_per_sheet && j <= ncols; j++)
printf(ftopbar,j+collwb-1);
printf("\n%s\n",topbar);
if (fNelems <= 0) continue;
for (Int_t i = 1; i <= nrows; i++) {
printf("%4d |",i+rowlwb-1);
for (Int_t j = sheet_counter; j < sheet_counter+cols_per_sheet && j <= ncols; j++)
printf(format,(*this)(i+rowlwb-1,j+collwb-1));
printf("\n");
}
}
printf("\n");
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator==(Element val) const
{
// Are all matrix elements equal to val?

R__ASSERT(IsValid());

if (val == 0. && fNelems == 0)
return kTRUE;

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep == val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator!=(Element val) const
{
// Are all matrix elements not equal to val?

R__ASSERT(IsValid());

if (val == 0. && fNelems == 0)
return kFALSE;

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep != val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator<(Element val) const
{
// Are all matrix elements < val?

R__ASSERT(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep < val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator<=(Element val) const
{
// Are all matrix elements <= val?

R__ASSERT(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep <= val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator>(Element val) const
{
// Are all matrix elements > val?

R__ASSERT(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep > val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TMatrixTBase<Element>::operator>=(Element val) const
{
// Are all matrix elements >= val?

R__ASSERT(IsValid());

const Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
for (; ep < fp; ep++)
if (!(*ep >= val))
return kFALSE;

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
TMatrixTBase<Element> &TMatrixTBase<Element>::Apply(const TElementActionT<Element> &action)
{
// Apply action to each matrix element

R__ASSERT(IsValid());

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

return *this;
}

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

R__ASSERT(IsValid());

Element *ep = this->GetMatrixArray();
for (action.fI = fRowLwb; action.fI < fRowLwb+fNrows; action.fI++)
for (action.fJ = fColLwb; action.fJ < fColLwb+fNcols; action.fJ++)
action.Operation(*ep++);

R__ASSERT(ep == this->GetMatrixArray()+fNelems);

return *this;
}

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

R__ASSERT(IsValid());

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

Element *       ep = GetMatrixArray();
const Element * const fp = ep+fNelems;
while (ep < fp)
*ep++ = scale*(Drand(seed)+shift);

return *this;
}

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

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

//______________________________________________________________________________
template<class Element>
Element E2Norm(const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2)
{
// Square of the Euclidian norm of the difference between two matrices.

if (gMatrixCheck && !AreCompatible(m1,m2)) {
::Error("E2Norm","matrices not compatible");
return -1.0;
}

const Element *        mp1 = m1.GetMatrixArray();
const Element *        mp2 = m2.GetMatrixArray();
const Element * const fmp1 = mp1+m1.GetNoElements();

Element sum = 0.0;
for (; mp1 < fmp1; mp1++, mp2++)
sum += (*mp1 - *mp2)*(*mp1 - *mp2);

return sum;
}

//______________________________________________________________________________
template<class Element1,class Element2>
Bool_t AreCompatible(const TMatrixTBase<Element1> &m1,const TMatrixTBase<Element2> &m2,Int_t verbose)
{
// Check that matrice sm1 and m2 areboth valid and have identical shapes .
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;
}

return kTRUE;
}

//______________________________________________________________________________
template<class Element>
void Compare(const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2)
{
// Compare two matrices and print out the result of the comparison.

if (!AreCompatible(m1,m2)) {
Error("Compare(const TMatrixTBase<Element> &,const TMatrixTBase<Element> &)","matrices are incompatible");
return;
}

printf("\n\nComparison of two TMatrices:\n");

Element norm1  = 0;      // Norm of the Matrices
Element norm2  = 0;
Element ndiff  = 0;      // Norm of the difference
Int_t   imax   = 0;      // For the elements that differ most
Int_t   jmax   = 0;
Element difmax = -1;

for (Int_t i = m1.GetRowLwb(); i <= m1.GetRowUpb(); i++) {
for (Int_t j = m1.GetColLwb(); j < m1.GetColUpb(); j++) {
const Element mv1 = m1(i,j);
const Element mv2 = m2(i,j);
const Element diff = TMath::Abs(mv1-mv2);

if (diff > difmax) {
difmax = diff;
imax = i;
jmax = j;
}
norm1 += TMath::Abs(mv1);
norm2 += TMath::Abs(mv2);
ndiff += TMath::Abs(diff);
}
}

printf("\nMaximal discrepancy    \t\t%g", difmax);
printf("\n   occured at the point\t\t(%d,%d)",imax,jmax);
const Element mv1 = m1(imax,jmax);
const Element mv2 = m2(imax,jmax);
printf("\n Matrix 1 element is    \t\t%g", mv1);
printf("\n Matrix 2 element is    \t\t%g", mv2);
printf("\n Absolute error v2[i]-v1[i]\t\t%g", mv2-mv1);
printf("\n Relative error\t\t\t\t%g\n",
(mv2-mv1)/TMath::Max(TMath::Abs(mv2+mv1)/2,(Element)1e-7));

printf("\n||Matrix 1||   \t\t\t%g", norm1);
printf("\n||Matrix 2||   \t\t\t%g", norm2);
printf("\n||Matrix1-Matrix2||\t\t\t\t%g", ndiff);
printf("\n||Matrix1-Matrix2||/sqrt(||Matrix1|| ||Matrix2||)\t%g\n\n",
ndiff/TMath::Max(TMath::Sqrt(norm1*norm2),1e-7));
}

//______________________________________________________________________________
template<class Element>
Bool_t VerifyMatrixValue(const TMatrixTBase<Element> &m,Element val,Int_t verbose,Element maxDevAllow)
{
// Validate that all elements of matrix have value val within maxDevAllow.

R__ASSERT(m.IsValid());

if (m == 0)
return kTRUE;

Int_t   imax      = 0;
Int_t   jmax      = 0;
Element maxDevObs = 0;

if (TMath::Abs(maxDevAllow) <= 0.0)
maxDevAllow = std::numeric_limits<Element>::epsilon();

for (Int_t i = m.GetRowLwb(); i <= m.GetRowUpb(); i++) {
for (Int_t j = m.GetColLwb(); j <= m.GetColUpb(); j++) {
const Element dev = TMath::Abs(m(i,j)-val);
if (dev > maxDevObs) {
imax    = i;
jmax    = j;
maxDevObs = dev;
}
}
}

if (maxDevObs == 0)
return kTRUE;

if (verbose) {
printf("Largest dev for (%d,%d); dev = |%g - %g| = %g\n",imax,jmax,m(imax,jmax),val,maxDevObs);
if(maxDevObs > maxDevAllow)
Error("VerifyElementValue","Deviation > %g\n",maxDevAllow);
}

if(maxDevObs > maxDevAllow)
return kFALSE;
return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t VerifyMatrixIdentity(const TMatrixTBase<Element> &m1,const TMatrixTBase<Element> &m2,Int_t verbose,
Element maxDevAllow)
{
// Verify that elements of the two matrices are equal within MaxDevAllow .

if (!AreCompatible(m1,m2,verbose))
return kFALSE;

if (m1 == 0 && m2 == 0)
return kTRUE;

Int_t   imax      = 0;
Int_t   jmax      = 0;
Element maxDevObs = 0;

if (TMath::Abs(maxDevAllow) <= 0.0)
maxDevAllow = std::numeric_limits<Element>::epsilon();

for (Int_t i = m1.GetRowLwb(); i <= m1.GetRowUpb(); i++) {
for (Int_t j = m1.GetColLwb(); j <= m1.GetColUpb(); j++) {
const Element dev = TMath::Abs(m1(i,j)-m2(i,j));
if (dev > maxDevObs) {
imax = i;
jmax = j;
maxDevObs = dev;
}
}
}

if (maxDevObs == 0)
return kTRUE;

if (verbose) {
printf("Largest dev for (%d,%d); dev = |%g - %g| = %g\n",
imax,jmax,m1(imax,jmax),m2(imax,jmax),maxDevObs);
if (maxDevObs > maxDevAllow)
Error("VerifyMatrixValue","Deviation > %g\n",maxDevAllow);
}

if (maxDevObs > maxDevAllow)
return kFALSE;
return kTRUE;
}

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

UInt_t R__s, R__c;
if (R__v > 1) {
} else {
Error("TMatrixTBase<Element>::Streamer","Unknown version number: %d",R__v);
R__ASSERT(0);
}
if (R__v < 4) MakeValid();
} else {
R__b.WriteClassBuffer(TMatrixTBase<Element>::Class(),this);
}
}

// trick to return a reference to nan in operator(i,j_ when i,j are outside of range
template<class Element>
struct nan_value_t {
static Element gNanValue;
};
template<>
Double_t nan_value_t<Double_t>::gNanValue = std::numeric_limits<Double_t>::quiet_NaN();
template<>
Float_t nan_value_t<Float_t>::gNanValue = std::numeric_limits<Float_t>::quiet_NaN();

template<class Element>
Element & TMatrixTBase<Element>::NaNValue()
{
return nan_value_t<Element>::gNanValue;
}

template class TMatrixTBase<Float_t>;

template Bool_t   operator==          <Float_t>(const TMatrixFBase &m1,const TMatrixFBase &m2);
template Float_t  E2Norm              <Float_t>(const TMatrixFBase &m1,const TMatrixFBase &m2);
template Bool_t   AreCompatible<Float_t,Float_t>
(const TMatrixFBase &m1,const TMatrixFBase &m2,Int_t verbose);
template Bool_t   AreCompatible<Float_t,Double_t>
(const TMatrixFBase &m1,const TMatrixDBase &m2,Int_t verbose);
template void     Compare             <Float_t>(const TMatrixFBase &m1,const TMatrixFBase &m2);
template Bool_t   VerifyMatrixValue   <Float_t>(const TMatrixFBase &m,Float_t val,Int_t verbose,Float_t maxDevAllow);
template Bool_t   VerifyMatrixValue   <Float_t>(const TMatrixFBase &m,Float_t val);
template Bool_t   VerifyMatrixIdentity<Float_t>(const TMatrixFBase &m1,const TMatrixFBase &m2,
Int_t verbose,Float_t maxDevAllowN);
template Bool_t   VerifyMatrixIdentity<Float_t>(const TMatrixFBase &m1,const TMatrixFBase &m2);

template class TMatrixTBase<Double_t>;

template Bool_t   operator==          <Double_t>(const TMatrixDBase &m1,const TMatrixDBase &m2);
template Double_t E2Norm              <Double_t>(const TMatrixDBase &m1,const TMatrixDBase &m2);
template Bool_t   AreCompatible<Double_t,Double_t>
(const TMatrixDBase &m1,const TMatrixDBase &m2,Int_t verbose);
template Bool_t   AreCompatible<Double_t,Float_t>
(const TMatrixDBase &m1,const TMatrixFBase &m2,Int_t verbose);
template void     Compare             <Double_t>(const TMatrixDBase &m1,const TMatrixDBase &m2);
template Bool_t   VerifyMatrixValue   <Double_t>(const TMatrixDBase &m,Double_t val,Int_t verbose,Double_t maxDevAllow);
template Bool_t   VerifyMatrixValue   <Double_t>(const TMatrixDBase &m,Double_t val);
template Bool_t   VerifyMatrixIdentity<Double_t>(const TMatrixDBase &m1,const TMatrixDBase &m2,
Int_t verbose,Double_t maxDevAllow);
template Bool_t   VerifyMatrixIdentity<Double_t>(const TMatrixDBase &m1,const TMatrixDBase &m2);
```
TMatrixTBase.cxx:1
TMatrixTBase.cxx:2
TMatrixTBase.cxx:3
TMatrixTBase.cxx:4
TMatrixTBase.cxx:5
TMatrixTBase.cxx:6
TMatrixTBase.cxx:7
TMatrixTBase.cxx:8
TMatrixTBase.cxx:9
TMatrixTBase.cxx:10
TMatrixTBase.cxx:11
TMatrixTBase.cxx:12
TMatrixTBase.cxx:13
TMatrixTBase.cxx:14
TMatrixTBase.cxx:15
TMatrixTBase.cxx:16
TMatrixTBase.cxx:17
TMatrixTBase.cxx:18
TMatrixTBase.cxx:19
TMatrixTBase.cxx:20
TMatrixTBase.cxx:21
TMatrixTBase.cxx:22
TMatrixTBase.cxx:23
TMatrixTBase.cxx:24
TMatrixTBase.cxx:25
TMatrixTBase.cxx:26
TMatrixTBase.cxx:27
TMatrixTBase.cxx:28
TMatrixTBase.cxx:29
TMatrixTBase.cxx:30
TMatrixTBase.cxx:31
TMatrixTBase.cxx:32
TMatrixTBase.cxx:33
TMatrixTBase.cxx:34
TMatrixTBase.cxx:35
TMatrixTBase.cxx:36
TMatrixTBase.cxx:37
TMatrixTBase.cxx:38
TMatrixTBase.cxx:39
TMatrixTBase.cxx:40
TMatrixTBase.cxx:41
TMatrixTBase.cxx:42
TMatrixTBase.cxx:43
TMatrixTBase.cxx:44
TMatrixTBase.cxx:45
TMatrixTBase.cxx:46
TMatrixTBase.cxx:47
TMatrixTBase.cxx:48
TMatrixTBase.cxx:49
TMatrixTBase.cxx:50
TMatrixTBase.cxx:51
TMatrixTBase.cxx:52
TMatrixTBase.cxx:53
TMatrixTBase.cxx:54
TMatrixTBase.cxx:55
TMatrixTBase.cxx:56
TMatrixTBase.cxx:57
TMatrixTBase.cxx:58
TMatrixTBase.cxx:59
TMatrixTBase.cxx:60
TMatrixTBase.cxx:61
TMatrixTBase.cxx:62
TMatrixTBase.cxx:63
TMatrixTBase.cxx:64
TMatrixTBase.cxx:65
TMatrixTBase.cxx:66
TMatrixTBase.cxx:67
TMatrixTBase.cxx:68
TMatrixTBase.cxx:69
TMatrixTBase.cxx:70
TMatrixTBase.cxx:71
TMatrixTBase.cxx:72
TMatrixTBase.cxx:73
TMatrixTBase.cxx:74
TMatrixTBase.cxx:75
TMatrixTBase.cxx:76
TMatrixTBase.cxx:77
TMatrixTBase.cxx:78
TMatrixTBase.cxx:79
TMatrixTBase.cxx:80
TMatrixTBase.cxx:81
TMatrixTBase.cxx:82
TMatrixTBase.cxx:83
TMatrixTBase.cxx:84
TMatrixTBase.cxx:85
TMatrixTBase.cxx:86
TMatrixTBase.cxx:87
TMatrixTBase.cxx:88
TMatrixTBase.cxx:89
TMatrixTBase.cxx:90
TMatrixTBase.cxx:91
TMatrixTBase.cxx:92
TMatrixTBase.cxx:93
TMatrixTBase.cxx:94
TMatrixTBase.cxx:95
TMatrixTBase.cxx:96
TMatrixTBase.cxx:97
TMatrixTBase.cxx:98
TMatrixTBase.cxx:99
TMatrixTBase.cxx:100
TMatrixTBase.cxx:101
TMatrixTBase.cxx:102
TMatrixTBase.cxx:103
TMatrixTBase.cxx:104
TMatrixTBase.cxx:105
TMatrixTBase.cxx:106
TMatrixTBase.cxx:107
TMatrixTBase.cxx:108
TMatrixTBase.cxx:109
TMatrixTBase.cxx:110
TMatrixTBase.cxx:111
TMatrixTBase.cxx:112
TMatrixTBase.cxx:113
TMatrixTBase.cxx:114
TMatrixTBase.cxx:115
TMatrixTBase.cxx:116
TMatrixTBase.cxx:117
TMatrixTBase.cxx:118
TMatrixTBase.cxx:119
TMatrixTBase.cxx:120
TMatrixTBase.cxx:121
TMatrixTBase.cxx:122
TMatrixTBase.cxx:123
TMatrixTBase.cxx:124
TMatrixTBase.cxx:125
TMatrixTBase.cxx:126
TMatrixTBase.cxx:127
TMatrixTBase.cxx:128
TMatrixTBase.cxx:129
TMatrixTBase.cxx:130
TMatrixTBase.cxx:131
TMatrixTBase.cxx:132
TMatrixTBase.cxx:133
TMatrixTBase.cxx:134
TMatrixTBase.cxx:135
TMatrixTBase.cxx:136
TMatrixTBase.cxx:137
TMatrixTBase.cxx:138
TMatrixTBase.cxx:139
TMatrixTBase.cxx:140
TMatrixTBase.cxx:141
TMatrixTBase.cxx:142
TMatrixTBase.cxx:143
TMatrixTBase.cxx:144
TMatrixTBase.cxx:145
TMatrixTBase.cxx:146
TMatrixTBase.cxx:147
TMatrixTBase.cxx:148
TMatrixTBase.cxx:149
TMatrixTBase.cxx:150
TMatrixTBase.cxx:151
TMatrixTBase.cxx:152
TMatrixTBase.cxx:153
TMatrixTBase.cxx:154
TMatrixTBase.cxx:155
TMatrixTBase.cxx:156
TMatrixTBase.cxx:157
TMatrixTBase.cxx:158
TMatrixTBase.cxx:159
TMatrixTBase.cxx:160
TMatrixTBase.cxx:161
TMatrixTBase.cxx:162
TMatrixTBase.cxx:163
TMatrixTBase.cxx:164
TMatrixTBase.cxx:165
TMatrixTBase.cxx:166
TMatrixTBase.cxx:167
TMatrixTBase.cxx:168
TMatrixTBase.cxx:169
TMatrixTBase.cxx:170
TMatrixTBase.cxx:171
TMatrixTBase.cxx:172
TMatrixTBase.cxx:173
TMatrixTBase.cxx:174
TMatrixTBase.cxx:175
TMatrixTBase.cxx:176
TMatrixTBase.cxx:177
TMatrixTBase.cxx:178
TMatrixTBase.cxx:179
TMatrixTBase.cxx:180
TMatrixTBase.cxx:181
TMatrixTBase.cxx:182
TMatrixTBase.cxx:183
TMatrixTBase.cxx:184
TMatrixTBase.cxx:185
TMatrixTBase.cxx:186
TMatrixTBase.cxx:187
TMatrixTBase.cxx:188
TMatrixTBase.cxx:189
TMatrixTBase.cxx:190
TMatrixTBase.cxx:191
TMatrixTBase.cxx:192
TMatrixTBase.cxx:193
TMatrixTBase.cxx:194
TMatrixTBase.cxx:195
TMatrixTBase.cxx:196
TMatrixTBase.cxx:197
TMatrixTBase.cxx:198
TMatrixTBase.cxx:199
TMatrixTBase.cxx:200
TMatrixTBase.cxx:201
TMatrixTBase.cxx:202
TMatrixTBase.cxx:203
TMatrixTBase.cxx:204
TMatrixTBase.cxx:205
TMatrixTBase.cxx:206
TMatrixTBase.cxx:207
TMatrixTBase.cxx:208
TMatrixTBase.cxx:209
TMatrixTBase.cxx:210
TMatrixTBase.cxx:211
TMatrixTBase.cxx:212
TMatrixTBase.cxx:213
TMatrixTBase.cxx:214
TMatrixTBase.cxx:215
TMatrixTBase.cxx:216
TMatrixTBase.cxx:217
TMatrixTBase.cxx:218
TMatrixTBase.cxx:219
TMatrixTBase.cxx:220
TMatrixTBase.cxx:221
TMatrixTBase.cxx:222
TMatrixTBase.cxx:223
TMatrixTBase.cxx:224
TMatrixTBase.cxx:225
TMatrixTBase.cxx:226
TMatrixTBase.cxx:227
TMatrixTBase.cxx:228
TMatrixTBase.cxx:229
TMatrixTBase.cxx:230
TMatrixTBase.cxx:231
TMatrixTBase.cxx:232
TMatrixTBase.cxx:233
TMatrixTBase.cxx:234
TMatrixTBase.cxx:235
TMatrixTBase.cxx:236
TMatrixTBase.cxx:237
TMatrixTBase.cxx:238
TMatrixTBase.cxx:239
TMatrixTBase.cxx:240
TMatrixTBase.cxx:241
TMatrixTBase.cxx:242
TMatrixTBase.cxx:243
TMatrixTBase.cxx:244
TMatrixTBase.cxx:245
TMatrixTBase.cxx:246
TMatrixTBase.cxx:247
TMatrixTBase.cxx:248
TMatrixTBase.cxx:249
TMatrixTBase.cxx:250
TMatrixTBase.cxx:251
TMatrixTBase.cxx:252
TMatrixTBase.cxx:253
TMatrixTBase.cxx:254
TMatrixTBase.cxx:255
TMatrixTBase.cxx:256
TMatrixTBase.cxx:257
TMatrixTBase.cxx:258
TMatrixTBase.cxx:259
TMatrixTBase.cxx:260
TMatrixTBase.cxx:261
TMatrixTBase.cxx:262
TMatrixTBase.cxx:263
TMatrixTBase.cxx:264
TMatrixTBase.cxx:265
TMatrixTBase.cxx:266
TMatrixTBase.cxx:267
TMatrixTBase.cxx:268
TMatrixTBase.cxx:269
TMatrixTBase.cxx:270
TMatrixTBase.cxx:271
TMatrixTBase.cxx:272
TMatrixTBase.cxx:273
TMatrixTBase.cxx:274
TMatrixTBase.cxx:275
TMatrixTBase.cxx:276
TMatrixTBase.cxx:277
TMatrixTBase.cxx:278
TMatrixTBase.cxx:279
TMatrixTBase.cxx:280
TMatrixTBase.cxx:281
TMatrixTBase.cxx:282
TMatrixTBase.cxx:283
TMatrixTBase.cxx:284
TMatrixTBase.cxx:285
TMatrixTBase.cxx:286
TMatrixTBase.cxx:287
TMatrixTBase.cxx:288
TMatrixTBase.cxx:289
TMatrixTBase.cxx:290
TMatrixTBase.cxx:291
TMatrixTBase.cxx:292
TMatrixTBase.cxx:293
TMatrixTBase.cxx:294
TMatrixTBase.cxx:295
TMatrixTBase.cxx:296
TMatrixTBase.cxx:297
TMatrixTBase.cxx:298
TMatrixTBase.cxx:299
TMatrixTBase.cxx:300
TMatrixTBase.cxx:301
TMatrixTBase.cxx:302
TMatrixTBase.cxx:303
TMatrixTBase.cxx:304
TMatrixTBase.cxx:305
TMatrixTBase.cxx:306
TMatrixTBase.cxx:307
TMatrixTBase.cxx:308
TMatrixTBase.cxx:309
TMatrixTBase.cxx:310
TMatrixTBase.cxx:311
TMatrixTBase.cxx:312
TMatrixTBase.cxx:313
TMatrixTBase.cxx:314
TMatrixTBase.cxx:315
TMatrixTBase.cxx:316
TMatrixTBase.cxx:317
TMatrixTBase.cxx:318
TMatrixTBase.cxx:319
TMatrixTBase.cxx:320
TMatrixTBase.cxx:321
TMatrixTBase.cxx:322
TMatrixTBase.cxx:323
TMatrixTBase.cxx:324
TMatrixTBase.cxx:325
TMatrixTBase.cxx:326
TMatrixTBase.cxx:327
TMatrixTBase.cxx:328
TMatrixTBase.cxx:329
TMatrixTBase.cxx:330
TMatrixTBase.cxx:331
TMatrixTBase.cxx:332
TMatrixTBase.cxx:333
TMatrixTBase.cxx:334
TMatrixTBase.cxx:335
TMatrixTBase.cxx:336
TMatrixTBase.cxx:337
TMatrixTBase.cxx:338
TMatrixTBase.cxx:339
TMatrixTBase.cxx:340
TMatrixTBase.cxx:341
TMatrixTBase.cxx:342
TMatrixTBase.cxx:343
TMatrixTBase.cxx:344
TMatrixTBase.cxx:345
TMatrixTBase.cxx:346
TMatrixTBase.cxx:347
TMatrixTBase.cxx:348
TMatrixTBase.cxx:349
TMatrixTBase.cxx:350
TMatrixTBase.cxx:351
TMatrixTBase.cxx:352
TMatrixTBase.cxx:353
TMatrixTBase.cxx:354
TMatrixTBase.cxx:355
TMatrixTBase.cxx:356
TMatrixTBase.cxx:357
TMatrixTBase.cxx:358
TMatrixTBase.cxx:359
TMatrixTBase.cxx:360
TMatrixTBase.cxx:361
TMatrixTBase.cxx:362
TMatrixTBase.cxx:363
TMatrixTBase.cxx:364
TMatrixTBase.cxx:365
TMatrixTBase.cxx:366
TMatrixTBase.cxx:367
TMatrixTBase.cxx:368
TMatrixTBase.cxx:369
TMatrixTBase.cxx:370
TMatrixTBase.cxx:371
TMatrixTBase.cxx:372
TMatrixTBase.cxx:373
TMatrixTBase.cxx:374
TMatrixTBase.cxx:375
TMatrixTBase.cxx:376
TMatrixTBase.cxx:377
TMatrixTBase.cxx:378
TMatrixTBase.cxx:379
TMatrixTBase.cxx:380
TMatrixTBase.cxx:381
TMatrixTBase.cxx:382
TMatrixTBase.cxx:383
TMatrixTBase.cxx:384
TMatrixTBase.cxx:385
TMatrixTBase.cxx:386
TMatrixTBase.cxx:387
TMatrixTBase.cxx:388
TMatrixTBase.cxx:389
TMatrixTBase.cxx:390
TMatrixTBase.cxx:391
TMatrixTBase.cxx:392
TMatrixTBase.cxx:393
TMatrixTBase.cxx:394
TMatrixTBase.cxx:395
TMatrixTBase.cxx:396
TMatrixTBase.cxx:397
TMatrixTBase.cxx:398
TMatrixTBase.cxx:399
TMatrixTBase.cxx:400
TMatrixTBase.cxx:401
TMatrixTBase.cxx:402
TMatrixTBase.cxx:403
TMatrixTBase.cxx:404
TMatrixTBase.cxx:405
TMatrixTBase.cxx:406
TMatrixTBase.cxx:407
TMatrixTBase.cxx:408
TMatrixTBase.cxx:409
TMatrixTBase.cxx:410
TMatrixTBase.cxx:411
TMatrixTBase.cxx:412
TMatrixTBase.cxx:413
TMatrixTBase.cxx:414
TMatrixTBase.cxx:415
TMatrixTBase.cxx:416
TMatrixTBase.cxx:417
TMatrixTBase.cxx:418
TMatrixTBase.cxx:419
TMatrixTBase.cxx:420
TMatrixTBase.cxx:421
TMatrixTBase.cxx:422
TMatrixTBase.cxx:423
TMatrixTBase.cxx:424
TMatrixTBase.cxx:425
TMatrixTBase.cxx:426
TMatrixTBase.cxx:427
TMatrixTBase.cxx:428
TMatrixTBase.cxx:429
TMatrixTBase.cxx:430
TMatrixTBase.cxx:431
TMatrixTBase.cxx:432
TMatrixTBase.cxx:433
TMatrixTBase.cxx:434
TMatrixTBase.cxx:435
TMatrixTBase.cxx:436
TMatrixTBase.cxx:437
TMatrixTBase.cxx:438
TMatrixTBase.cxx:439
TMatrixTBase.cxx:440
TMatrixTBase.cxx:441
TMatrixTBase.cxx:442
TMatrixTBase.cxx:443
TMatrixTBase.cxx:444
TMatrixTBase.cxx:445
TMatrixTBase.cxx:446
TMatrixTBase.cxx:447
TMatrixTBase.cxx:448
TMatrixTBase.cxx:449
TMatrixTBase.cxx:450
TMatrixTBase.cxx:451
TMatrixTBase.cxx:452
TMatrixTBase.cxx:453
TMatrixTBase.cxx:454
TMatrixTBase.cxx:455
TMatrixTBase.cxx:456
TMatrixTBase.cxx:457
TMatrixTBase.cxx:458
TMatrixTBase.cxx:459
TMatrixTBase.cxx:460
TMatrixTBase.cxx:461
TMatrixTBase.cxx:462
TMatrixTBase.cxx:463
TMatrixTBase.cxx:464
TMatrixTBase.cxx:465
TMatrixTBase.cxx:466
TMatrixTBase.cxx:467
TMatrixTBase.cxx:468
TMatrixTBase.cxx:469
TMatrixTBase.cxx:470
TMatrixTBase.cxx:471
TMatrixTBase.cxx:472
TMatrixTBase.cxx:473
TMatrixTBase.cxx:474
TMatrixTBase.cxx:475
TMatrixTBase.cxx:476
TMatrixTBase.cxx:477
TMatrixTBase.cxx:478
TMatrixTBase.cxx:479
TMatrixTBase.cxx:480
TMatrixTBase.cxx:481
TMatrixTBase.cxx:482
TMatrixTBase.cxx:483
TMatrixTBase.cxx:484
TMatrixTBase.cxx:485
TMatrixTBase.cxx:486
TMatrixTBase.cxx:487
TMatrixTBase.cxx:488
TMatrixTBase.cxx:489
TMatrixTBase.cxx:490
TMatrixTBase.cxx:491
TMatrixTBase.cxx:492
TMatrixTBase.cxx:493
TMatrixTBase.cxx:494
TMatrixTBase.cxx:495
TMatrixTBase.cxx:496
TMatrixTBase.cxx:497
TMatrixTBase.cxx:498
TMatrixTBase.cxx:499
TMatrixTBase.cxx:500
TMatrixTBase.cxx:501
TMatrixTBase.cxx:502
TMatrixTBase.cxx:503
TMatrixTBase.cxx:504
TMatrixTBase.cxx:505
TMatrixTBase.cxx:506
TMatrixTBase.cxx:507
TMatrixTBase.cxx:508
TMatrixTBase.cxx:509
TMatrixTBase.cxx:510
TMatrixTBase.cxx:511
TMatrixTBase.cxx:512
TMatrixTBase.cxx:513
TMatrixTBase.cxx:514
TMatrixTBase.cxx:515
TMatrixTBase.cxx:516
TMatrixTBase.cxx:517
TMatrixTBase.cxx:518
TMatrixTBase.cxx:519
TMatrixTBase.cxx:520
TMatrixTBase.cxx:521
TMatrixTBase.cxx:522
TMatrixTBase.cxx:523
TMatrixTBase.cxx:524
TMatrixTBase.cxx:525
TMatrixTBase.cxx:526
TMatrixTBase.cxx:527
TMatrixTBase.cxx:528
TMatrixTBase.cxx:529
TMatrixTBase.cxx:530
TMatrixTBase.cxx:531
TMatrixTBase.cxx:532
TMatrixTBase.cxx:533
TMatrixTBase.cxx:534
TMatrixTBase.cxx:535
TMatrixTBase.cxx:536
TMatrixTBase.cxx:537
TMatrixTBase.cxx:538
TMatrixTBase.cxx:539
TMatrixTBase.cxx:540
TMatrixTBase.cxx:541
TMatrixTBase.cxx:542
TMatrixTBase.cxx:543
TMatrixTBase.cxx:544
TMatrixTBase.cxx:545
TMatrixTBase.cxx:546
TMatrixTBase.cxx:547
TMatrixTBase.cxx:548
TMatrixTBase.cxx:549
TMatrixTBase.cxx:550
TMatrixTBase.cxx:551
TMatrixTBase.cxx:552
TMatrixTBase.cxx:553
TMatrixTBase.cxx:554
TMatrixTBase.cxx:555
TMatrixTBase.cxx:556
TMatrixTBase.cxx:557
TMatrixTBase.cxx:558
TMatrixTBase.cxx:559
TMatrixTBase.cxx:560
TMatrixTBase.cxx:561
TMatrixTBase.cxx:562
TMatrixTBase.cxx:563
TMatrixTBase.cxx:564
TMatrixTBase.cxx:565
TMatrixTBase.cxx:566
TMatrixTBase.cxx:567
TMatrixTBase.cxx:568
TMatrixTBase.cxx:569
TMatrixTBase.cxx:570
TMatrixTBase.cxx:571
TMatrixTBase.cxx:572
TMatrixTBase.cxx:573
TMatrixTBase.cxx:574
TMatrixTBase.cxx:575
TMatrixTBase.cxx:576
TMatrixTBase.cxx:577
TMatrixTBase.cxx:578
TMatrixTBase.cxx:579
TMatrixTBase.cxx:580
TMatrixTBase.cxx:581
TMatrixTBase.cxx:582
TMatrixTBase.cxx:583
TMatrixTBase.cxx:584
TMatrixTBase.cxx:585
TMatrixTBase.cxx:586
TMatrixTBase.cxx:587
TMatrixTBase.cxx:588
TMatrixTBase.cxx:589
TMatrixTBase.cxx:590
TMatrixTBase.cxx:591
TMatrixTBase.cxx:592
TMatrixTBase.cxx:593
TMatrixTBase.cxx:594
TMatrixTBase.cxx:595
TMatrixTBase.cxx:596
TMatrixTBase.cxx:597
TMatrixTBase.cxx:598
TMatrixTBase.cxx:599
TMatrixTBase.cxx:600
TMatrixTBase.cxx:601
TMatrixTBase.cxx:602
TMatrixTBase.cxx:603
TMatrixTBase.cxx:604
TMatrixTBase.cxx:605
TMatrixTBase.cxx:606
TMatrixTBase.cxx:607
TMatrixTBase.cxx:608
TMatrixTBase.cxx:609
TMatrixTBase.cxx:610
TMatrixTBase.cxx:611
TMatrixTBase.cxx:612
TMatrixTBase.cxx:613
TMatrixTBase.cxx:614
TMatrixTBase.cxx:615
TMatrixTBase.cxx:616
TMatrixTBase.cxx:617
TMatrixTBase.cxx:618
TMatrixTBase.cxx:619
TMatrixTBase.cxx:620
TMatrixTBase.cxx:621
TMatrixTBase.cxx:622
TMatrixTBase.cxx:623
TMatrixTBase.cxx:624
TMatrixTBase.cxx:625
TMatrixTBase.cxx:626
TMatrixTBase.cxx:627
TMatrixTBase.cxx:628
TMatrixTBase.cxx:629
TMatrixTBase.cxx:630
TMatrixTBase.cxx:631
TMatrixTBase.cxx:632
TMatrixTBase.cxx:633
TMatrixTBase.cxx:634
TMatrixTBase.cxx:635
TMatrixTBase.cxx:636
TMatrixTBase.cxx:637
TMatrixTBase.cxx:638
TMatrixTBase.cxx:639
TMatrixTBase.cxx:640
TMatrixTBase.cxx:641
TMatrixTBase.cxx:642
TMatrixTBase.cxx:643
TMatrixTBase.cxx:644
TMatrixTBase.cxx:645
TMatrixTBase.cxx:646
TMatrixTBase.cxx:647
TMatrixTBase.cxx:648
TMatrixTBase.cxx:649
TMatrixTBase.cxx:650
TMatrixTBase.cxx:651
TMatrixTBase.cxx:652
TMatrixTBase.cxx:653
TMatrixTBase.cxx:654
TMatrixTBase.cxx:655
TMatrixTBase.cxx:656
TMatrixTBase.cxx:657
TMatrixTBase.cxx:658
TMatrixTBase.cxx:659
TMatrixTBase.cxx:660
TMatrixTBase.cxx:661
TMatrixTBase.cxx:662
TMatrixTBase.cxx:663
TMatrixTBase.cxx:664
TMatrixTBase.cxx:665
TMatrixTBase.cxx:666
TMatrixTBase.cxx:667
TMatrixTBase.cxx:668
TMatrixTBase.cxx:669
TMatrixTBase.cxx:670
TMatrixTBase.cxx:671
TMatrixTBase.cxx:672
TMatrixTBase.cxx:673
TMatrixTBase.cxx:674
TMatrixTBase.cxx:675
TMatrixTBase.cxx:676
TMatrixTBase.cxx:677
TMatrixTBase.cxx:678
TMatrixTBase.cxx:679
TMatrixTBase.cxx:680
TMatrixTBase.cxx:681
TMatrixTBase.cxx:682
TMatrixTBase.cxx:683
TMatrixTBase.cxx:684
TMatrixTBase.cxx:685
TMatrixTBase.cxx:686
TMatrixTBase.cxx:687
TMatrixTBase.cxx:688
TMatrixTBase.cxx:689
TMatrixTBase.cxx:690
TMatrixTBase.cxx:691
TMatrixTBase.cxx:692
TMatrixTBase.cxx:693
TMatrixTBase.cxx:694
TMatrixTBase.cxx:695
TMatrixTBase.cxx:696
TMatrixTBase.cxx:697
TMatrixTBase.cxx:698
TMatrixTBase.cxx:699
TMatrixTBase.cxx:700
TMatrixTBase.cxx:701
TMatrixTBase.cxx:702
TMatrixTBase.cxx:703
TMatrixTBase.cxx:704
TMatrixTBase.cxx:705
TMatrixTBase.cxx:706
TMatrixTBase.cxx:707
TMatrixTBase.cxx:708
TMatrixTBase.cxx:709
TMatrixTBase.cxx:710
TMatrixTBase.cxx:711
TMatrixTBase.cxx:712
TMatrixTBase.cxx:713
TMatrixTBase.cxx:714
TMatrixTBase.cxx:715
TMatrixTBase.cxx:716
TMatrixTBase.cxx:717
TMatrixTBase.cxx:718
TMatrixTBase.cxx:719
TMatrixTBase.cxx:720
TMatrixTBase.cxx:721
TMatrixTBase.cxx:722
TMatrixTBase.cxx:723
TMatrixTBase.cxx:724
TMatrixTBase.cxx:725
TMatrixTBase.cxx:726
TMatrixTBase.cxx:727
TMatrixTBase.cxx:728
TMatrixTBase.cxx:729
TMatrixTBase.cxx:730
TMatrixTBase.cxx:731
TMatrixTBase.cxx:732
TMatrixTBase.cxx:733
TMatrixTBase.cxx:734
TMatrixTBase.cxx:735
TMatrixTBase.cxx:736
TMatrixTBase.cxx:737
TMatrixTBase.cxx:738
TMatrixTBase.cxx:739
TMatrixTBase.cxx:740
TMatrixTBase.cxx:741
TMatrixTBase.cxx:742
TMatrixTBase.cxx:743
TMatrixTBase.cxx:744
TMatrixTBase.cxx:745
TMatrixTBase.cxx:746
TMatrixTBase.cxx:747
TMatrixTBase.cxx:748
TMatrixTBase.cxx:749
TMatrixTBase.cxx:750
TMatrixTBase.cxx:751
TMatrixTBase.cxx:752
TMatrixTBase.cxx:753
TMatrixTBase.cxx:754
TMatrixTBase.cxx:755
TMatrixTBase.cxx:756
TMatrixTBase.cxx:757
TMatrixTBase.cxx:758
TMatrixTBase.cxx:759
TMatrixTBase.cxx:760
TMatrixTBase.cxx:761
TMatrixTBase.cxx:762
TMatrixTBase.cxx:763
TMatrixTBase.cxx:764
TMatrixTBase.cxx:765
TMatrixTBase.cxx:766
TMatrixTBase.cxx:767
TMatrixTBase.cxx:768
TMatrixTBase.cxx:769
TMatrixTBase.cxx:770
TMatrixTBase.cxx:771
TMatrixTBase.cxx:772
TMatrixTBase.cxx:773
TMatrixTBase.cxx:774
TMatrixTBase.cxx:775
TMatrixTBase.cxx:776
TMatrixTBase.cxx:777
TMatrixTBase.cxx:778
TMatrixTBase.cxx:779
TMatrixTBase.cxx:780
TMatrixTBase.cxx:781
TMatrixTBase.cxx:782
TMatrixTBase.cxx:783
TMatrixTBase.cxx:784
TMatrixTBase.cxx:785
TMatrixTBase.cxx:786
TMatrixTBase.cxx:787
TMatrixTBase.cxx:788
TMatrixTBase.cxx:789
TMatrixTBase.cxx:790
TMatrixTBase.cxx:791
TMatrixTBase.cxx:792
TMatrixTBase.cxx:793
TMatrixTBase.cxx:794
TMatrixTBase.cxx:795
TMatrixTBase.cxx:796
TMatrixTBase.cxx:797
TMatrixTBase.cxx:798
TMatrixTBase.cxx:799
TMatrixTBase.cxx:800
TMatrixTBase.cxx:801
TMatrixTBase.cxx:802
TMatrixTBase.cxx:803
TMatrixTBase.cxx:804
TMatrixTBase.cxx:805
TMatrixTBase.cxx:806
TMatrixTBase.cxx:807
TMatrixTBase.cxx:808
TMatrixTBase.cxx:809
TMatrixTBase.cxx:810
TMatrixTBase.cxx:811
TMatrixTBase.cxx:812
TMatrixTBase.cxx:813
TMatrixTBase.cxx:814
TMatrixTBase.cxx:815
TMatrixTBase.cxx:816
TMatrixTBase.cxx:817
TMatrixTBase.cxx:818
TMatrixTBase.cxx:819
TMatrixTBase.cxx:820
TMatrixTBase.cxx:821
TMatrixTBase.cxx:822
TMatrixTBase.cxx:823
TMatrixTBase.cxx:824
TMatrixTBase.cxx:825
TMatrixTBase.cxx:826
TMatrixTBase.cxx:827
TMatrixTBase.cxx:828
TMatrixTBase.cxx:829
TMatrixTBase.cxx:830
TMatrixTBase.cxx:831
TMatrixTBase.cxx:832
TMatrixTBase.cxx:833
TMatrixTBase.cxx:834
TMatrixTBase.cxx:835
TMatrixTBase.cxx:836
TMatrixTBase.cxx:837
TMatrixTBase.cxx:838
TMatrixTBase.cxx:839
TMatrixTBase.cxx:840
TMatrixTBase.cxx:841
TMatrixTBase.cxx:842
TMatrixTBase.cxx:843
TMatrixTBase.cxx:844
TMatrixTBase.cxx:845
TMatrixTBase.cxx:846
TMatrixTBase.cxx:847
TMatrixTBase.cxx:848
TMatrixTBase.cxx:849
TMatrixTBase.cxx:850
TMatrixTBase.cxx:851
TMatrixTBase.cxx:852
TMatrixTBase.cxx:853
TMatrixTBase.cxx:854
TMatrixTBase.cxx:855
TMatrixTBase.cxx:856
TMatrixTBase.cxx:857
TMatrixTBase.cxx:858
TMatrixTBase.cxx:859
TMatrixTBase.cxx:860
TMatrixTBase.cxx:861
TMatrixTBase.cxx:862
TMatrixTBase.cxx:863
TMatrixTBase.cxx:864
TMatrixTBase.cxx:865
TMatrixTBase.cxx:866
TMatrixTBase.cxx:867
TMatrixTBase.cxx:868
TMatrixTBase.cxx:869
TMatrixTBase.cxx:870
TMatrixTBase.cxx:871
TMatrixTBase.cxx:872
TMatrixTBase.cxx:873
TMatrixTBase.cxx:874
TMatrixTBase.cxx:875
TMatrixTBase.cxx:876
TMatrixTBase.cxx:877
TMatrixTBase.cxx:878
TMatrixTBase.cxx:879
TMatrixTBase.cxx:880
TMatrixTBase.cxx:881
TMatrixTBase.cxx:882
TMatrixTBase.cxx:883
TMatrixTBase.cxx:884
TMatrixTBase.cxx:885
TMatrixTBase.cxx:886
TMatrixTBase.cxx:887
TMatrixTBase.cxx:888
TMatrixTBase.cxx:889
TMatrixTBase.cxx:890
TMatrixTBase.cxx:891
TMatrixTBase.cxx:892
TMatrixTBase.cxx:893
TMatrixTBase.cxx:894
TMatrixTBase.cxx:895
TMatrixTBase.cxx:896
TMatrixTBase.cxx:897
TMatrixTBase.cxx:898
TMatrixTBase.cxx:899
TMatrixTBase.cxx:900
TMatrixTBase.cxx:901
TMatrixTBase.cxx:902
TMatrixTBase.cxx:903
TMatrixTBase.cxx:904
TMatrixTBase.cxx:905
TMatrixTBase.cxx:906
TMatrixTBase.cxx:907
TMatrixTBase.cxx:908
TMatrixTBase.cxx:909
TMatrixTBase.cxx:910
TMatrixTBase.cxx:911
TMatrixTBase.cxx:912
TMatrixTBase.cxx:913
TMatrixTBase.cxx:914
TMatrixTBase.cxx:915
TMatrixTBase.cxx:916
TMatrixTBase.cxx:917
TMatrixTBase.cxx:918
TMatrixTBase.cxx:919
TMatrixTBase.cxx:920
TMatrixTBase.cxx:921
TMatrixTBase.cxx:922
TMatrixTBase.cxx:923
TMatrixTBase.cxx:924
TMatrixTBase.cxx:925
TMatrixTBase.cxx:926
TMatrixTBase.cxx:927
TMatrixTBase.cxx:928
TMatrixTBase.cxx:929
TMatrixTBase.cxx:930
TMatrixTBase.cxx:931
TMatrixTBase.cxx:932
TMatrixTBase.cxx:933
TMatrixTBase.cxx:934
TMatrixTBase.cxx:935
TMatrixTBase.cxx:936
TMatrixTBase.cxx:937
TMatrixTBase.cxx:938
TMatrixTBase.cxx:939
TMatrixTBase.cxx:940
TMatrixTBase.cxx:941
TMatrixTBase.cxx:942
TMatrixTBase.cxx:943
TMatrixTBase.cxx:944
TMatrixTBase.cxx:945
TMatrixTBase.cxx:946
TMatrixTBase.cxx:947
TMatrixTBase.cxx:948
TMatrixTBase.cxx:949
TMatrixTBase.cxx:950
TMatrixTBase.cxx:951
TMatrixTBase.cxx:952
TMatrixTBase.cxx:953
TMatrixTBase.cxx:954
TMatrixTBase.cxx:955
TMatrixTBase.cxx:956
TMatrixTBase.cxx:957
TMatrixTBase.cxx:958
TMatrixTBase.cxx:959
TMatrixTBase.cxx:960
TMatrixTBase.cxx:961
TMatrixTBase.cxx:962
TMatrixTBase.cxx:963
TMatrixTBase.cxx:964
TMatrixTBase.cxx:965
TMatrixTBase.cxx:966
TMatrixTBase.cxx:967
TMatrixTBase.cxx:968
TMatrixTBase.cxx:969
TMatrixTBase.cxx:970
TMatrixTBase.cxx:971
TMatrixTBase.cxx:972
TMatrixTBase.cxx:973
TMatrixTBase.cxx:974
TMatrixTBase.cxx:975
TMatrixTBase.cxx:976
TMatrixTBase.cxx:977
TMatrixTBase.cxx:978
TMatrixTBase.cxx:979
TMatrixTBase.cxx:980
TMatrixTBase.cxx:981
TMatrixTBase.cxx:982
TMatrixTBase.cxx:983
TMatrixTBase.cxx:984
TMatrixTBase.cxx:985
TMatrixTBase.cxx:986
TMatrixTBase.cxx:987
TMatrixTBase.cxx:988
TMatrixTBase.cxx:989
TMatrixTBase.cxx:990
TMatrixTBase.cxx:991
TMatrixTBase.cxx:992
TMatrixTBase.cxx:993
TMatrixTBase.cxx:994
TMatrixTBase.cxx:995
TMatrixTBase.cxx:996
TMatrixTBase.cxx:997
TMatrixTBase.cxx:998
TMatrixTBase.cxx:999
TMatrixTBase.cxx:1000
TMatrixTBase.cxx:1001
TMatrixTBase.cxx:1002
TMatrixTBase.cxx:1003
TMatrixTBase.cxx:1004
TMatrixTBase.cxx:1005
TMatrixTBase.cxx:1006
TMatrixTBase.cxx:1007
TMatrixTBase.cxx:1008
TMatrixTBase.cxx:1009
TMatrixTBase.cxx:1010
TMatrixTBase.cxx:1011
TMatrixTBase.cxx:1012
TMatrixTBase.cxx:1013
TMatrixTBase.cxx:1014
TMatrixTBase.cxx:1015
TMatrixTBase.cxx:1016
TMatrixTBase.cxx:1017
TMatrixTBase.cxx:1018
TMatrixTBase.cxx:1019
TMatrixTBase.cxx:1020
TMatrixTBase.cxx:1021
TMatrixTBase.cxx:1022
TMatrixTBase.cxx:1023
TMatrixTBase.cxx:1024
TMatrixTBase.cxx:1025
TMatrixTBase.cxx:1026
TMatrixTBase.cxx:1027
TMatrixTBase.cxx:1028
TMatrixTBase.cxx:1029
TMatrixTBase.cxx:1030
TMatrixTBase.cxx:1031
TMatrixTBase.cxx:1032
TMatrixTBase.cxx:1033
TMatrixTBase.cxx:1034
TMatrixTBase.cxx:1035
TMatrixTBase.cxx:1036
TMatrixTBase.cxx:1037
TMatrixTBase.cxx:1038
TMatrixTBase.cxx:1039
TMatrixTBase.cxx:1040
TMatrixTBase.cxx:1041
TMatrixTBase.cxx:1042
TMatrixTBase.cxx:1043
TMatrixTBase.cxx:1044
TMatrixTBase.cxx:1045
TMatrixTBase.cxx:1046
TMatrixTBase.cxx:1047
TMatrixTBase.cxx:1048
TMatrixTBase.cxx:1049
TMatrixTBase.cxx:1050
TMatrixTBase.cxx:1051
TMatrixTBase.cxx:1052
TMatrixTBase.cxx:1053
TMatrixTBase.cxx:1054
TMatrixTBase.cxx:1055
TMatrixTBase.cxx:1056
TMatrixTBase.cxx:1057
TMatrixTBase.cxx:1058
TMatrixTBase.cxx:1059
TMatrixTBase.cxx:1060
TMatrixTBase.cxx:1061
TMatrixTBase.cxx:1062
TMatrixTBase.cxx:1063
TMatrixTBase.cxx:1064
TMatrixTBase.cxx:1065
TMatrixTBase.cxx:1066
TMatrixTBase.cxx:1067
TMatrixTBase.cxx:1068
TMatrixTBase.cxx:1069
TMatrixTBase.cxx:1070
TMatrixTBase.cxx:1071
TMatrixTBase.cxx:1072
TMatrixTBase.cxx:1073
TMatrixTBase.cxx:1074
TMatrixTBase.cxx:1075
TMatrixTBase.cxx:1076
TMatrixTBase.cxx:1077
TMatrixTBase.cxx:1078
TMatrixTBase.cxx:1079
TMatrixTBase.cxx:1080
TMatrixTBase.cxx:1081
TMatrixTBase.cxx:1082
TMatrixTBase.cxx:1083
TMatrixTBase.cxx:1084
TMatrixTBase.cxx:1085
TMatrixTBase.cxx:1086
TMatrixTBase.cxx:1087
TMatrixTBase.cxx:1088
TMatrixTBase.cxx:1089
TMatrixTBase.cxx:1090
TMatrixTBase.cxx:1091
TMatrixTBase.cxx:1092
TMatrixTBase.cxx:1093
TMatrixTBase.cxx:1094
TMatrixTBase.cxx:1095
TMatrixTBase.cxx:1096
TMatrixTBase.cxx:1097
TMatrixTBase.cxx:1098
TMatrixTBase.cxx:1099
TMatrixTBase.cxx:1100
TMatrixTBase.cxx:1101
TMatrixTBase.cxx:1102
TMatrixTBase.cxx:1103
TMatrixTBase.cxx:1104
TMatrixTBase.cxx:1105
TMatrixTBase.cxx:1106
TMatrixTBase.cxx:1107
TMatrixTBase.cxx:1108
TMatrixTBase.cxx:1109
TMatrixTBase.cxx:1110
TMatrixTBase.cxx:1111
TMatrixTBase.cxx:1112
TMatrixTBase.cxx:1113
TMatrixTBase.cxx:1114
TMatrixTBase.cxx:1115
TMatrixTBase.cxx:1116
TMatrixTBase.cxx:1117
TMatrixTBase.cxx:1118
TMatrixTBase.cxx:1119
TMatrixTBase.cxx:1120
TMatrixTBase.cxx:1121
TMatrixTBase.cxx:1122
TMatrixTBase.cxx:1123
TMatrixTBase.cxx:1124
TMatrixTBase.cxx:1125
TMatrixTBase.cxx:1126
TMatrixTBase.cxx:1127
TMatrixTBase.cxx:1128
TMatrixTBase.cxx:1129
TMatrixTBase.cxx:1130
TMatrixTBase.cxx:1131
TMatrixTBase.cxx:1132
TMatrixTBase.cxx:1133
TMatrixTBase.cxx:1134
TMatrixTBase.cxx:1135
TMatrixTBase.cxx:1136
TMatrixTBase.cxx:1137
TMatrixTBase.cxx:1138
TMatrixTBase.cxx:1139
TMatrixTBase.cxx:1140
TMatrixTBase.cxx:1141
TMatrixTBase.cxx:1142
TMatrixTBase.cxx:1143
TMatrixTBase.cxx:1144
TMatrixTBase.cxx:1145
TMatrixTBase.cxx:1146
TMatrixTBase.cxx:1147
TMatrixTBase.cxx:1148
TMatrixTBase.cxx:1149
TMatrixTBase.cxx:1150
TMatrixTBase.cxx:1151
TMatrixTBase.cxx:1152
TMatrixTBase.cxx:1153
TMatrixTBase.cxx:1154
TMatrixTBase.cxx:1155
TMatrixTBase.cxx:1156
TMatrixTBase.cxx:1157
TMatrixTBase.cxx:1158
TMatrixTBase.cxx:1159
TMatrixTBase.cxx:1160
TMatrixTBase.cxx:1161
TMatrixTBase.cxx:1162
TMatrixTBase.cxx:1163
TMatrixTBase.cxx:1164
TMatrixTBase.cxx:1165
TMatrixTBase.cxx:1166
TMatrixTBase.cxx:1167
TMatrixTBase.cxx:1168
TMatrixTBase.cxx:1169
TMatrixTBase.cxx:1170
TMatrixTBase.cxx:1171
TMatrixTBase.cxx:1172
TMatrixTBase.cxx:1173
TMatrixTBase.cxx:1174
TMatrixTBase.cxx:1175
TMatrixTBase.cxx:1176
TMatrixTBase.cxx:1177
TMatrixTBase.cxx:1178
TMatrixTBase.cxx:1179
TMatrixTBase.cxx:1180
TMatrixTBase.cxx:1181
TMatrixTBase.cxx:1182
TMatrixTBase.cxx:1183
TMatrixTBase.cxx:1184
TMatrixTBase.cxx:1185
TMatrixTBase.cxx:1186
TMatrixTBase.cxx:1187
TMatrixTBase.cxx:1188
TMatrixTBase.cxx:1189
TMatrixTBase.cxx:1190
TMatrixTBase.cxx:1191
TMatrixTBase.cxx:1192
TMatrixTBase.cxx:1193
TMatrixTBase.cxx:1194
TMatrixTBase.cxx:1195
TMatrixTBase.cxx:1196
TMatrixTBase.cxx:1197
TMatrixTBase.cxx:1198
TMatrixTBase.cxx:1199
TMatrixTBase.cxx:1200
TMatrixTBase.cxx:1201
TMatrixTBase.cxx:1202
TMatrixTBase.cxx:1203
TMatrixTBase.cxx:1204
TMatrixTBase.cxx:1205
TMatrixTBase.cxx:1206
TMatrixTBase.cxx:1207
TMatrixTBase.cxx:1208
TMatrixTBase.cxx:1209
TMatrixTBase.cxx:1210
TMatrixTBase.cxx:1211
TMatrixTBase.cxx:1212
TMatrixTBase.cxx:1213
TMatrixTBase.cxx:1214
TMatrixTBase.cxx:1215
TMatrixTBase.cxx:1216
TMatrixTBase.cxx:1217
TMatrixTBase.cxx:1218
TMatrixTBase.cxx:1219
TMatrixTBase.cxx:1220
TMatrixTBase.cxx:1221
TMatrixTBase.cxx:1222
TMatrixTBase.cxx:1223
TMatrixTBase.cxx:1224
TMatrixTBase.cxx:1225
TMatrixTBase.cxx:1226
TMatrixTBase.cxx:1227
TMatrixTBase.cxx:1228
TMatrixTBase.cxx:1229
TMatrixTBase.cxx:1230
TMatrixTBase.cxx:1231
TMatrixTBase.cxx:1232
TMatrixTBase.cxx:1233
TMatrixTBase.cxx:1234
TMatrixTBase.cxx:1235
TMatrixTBase.cxx:1236
TMatrixTBase.cxx:1237
TMatrixTBase.cxx:1238
TMatrixTBase.cxx:1239
TMatrixTBase.cxx:1240
TMatrixTBase.cxx:1241
TMatrixTBase.cxx:1242
TMatrixTBase.cxx:1243
TMatrixTBase.cxx:1244
TMatrixTBase.cxx:1245
TMatrixTBase.cxx:1246
TMatrixTBase.cxx:1247
TMatrixTBase.cxx:1248
TMatrixTBase.cxx:1249
TMatrixTBase.cxx:1250
TMatrixTBase.cxx:1251
TMatrixTBase.cxx:1252
TMatrixTBase.cxx:1253
TMatrixTBase.cxx:1254
TMatrixTBase.cxx:1255
TMatrixTBase.cxx:1256
TMatrixTBase.cxx:1257
TMatrixTBase.cxx:1258
TMatrixTBase.cxx:1259
TMatrixTBase.cxx:1260
TMatrixTBase.cxx:1261
TMatrixTBase.cxx:1262
TMatrixTBase.cxx:1263
TMatrixTBase.cxx:1264
TMatrixTBase.cxx:1265
TMatrixTBase.cxx:1266
TMatrixTBase.cxx:1267
TMatrixTBase.cxx:1268
TMatrixTBase.cxx:1269
TMatrixTBase.cxx:1270
TMatrixTBase.cxx:1271
TMatrixTBase.cxx:1272
TMatrixTBase.cxx:1273
TMatrixTBase.cxx:1274
TMatrixTBase.cxx:1275
TMatrixTBase.cxx:1276
TMatrixTBase.cxx:1277
TMatrixTBase.cxx:1278
TMatrixTBase.cxx:1279
TMatrixTBase.cxx:1280
TMatrixTBase.cxx:1281
TMatrixTBase.cxx:1282
TMatrixTBase.cxx:1283
TMatrixTBase.cxx:1284
TMatrixTBase.cxx:1285
TMatrixTBase.cxx:1286
TMatrixTBase.cxx:1287
TMatrixTBase.cxx:1288
TMatrixTBase.cxx:1289
TMatrixTBase.cxx:1290
TMatrixTBase.cxx:1291
TMatrixTBase.cxx:1292
TMatrixTBase.cxx:1293
TMatrixTBase.cxx:1294
TMatrixTBase.cxx:1295
TMatrixTBase.cxx:1296
TMatrixTBase.cxx:1297
TMatrixTBase.cxx:1298