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

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

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

#include <iostream>
#include <typeinfo>

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

templateClassImp(TMatrixT)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

R__ASSERT(prototype.IsValid());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return *this;
}

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

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

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

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

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

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

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

return target;
}

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

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

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

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

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

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

return *this;
}

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

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

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

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

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

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

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

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

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

return *this;
}

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

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

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

if (this->fNelems > 0) {

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

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

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

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

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

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

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

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

return *this;
}

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

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

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

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

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

R__ASSERT(this->IsValid());
TDecompLU::InvertLU(*this, Double_t(fTol), det);
return *this;
}

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

TMatrixD tmp(*this);
if (TDecompLU::InvertLU(tmp, Double_t(this->fTol),det))
std::copy(tmp.GetMatrixArray(), tmp.GetMatrixArray() + this->GetNoElements(), this->GetMatrixArray());

return *this;
}

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

R__ASSERT(this->IsValid());

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

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

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

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

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

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

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

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

return *this;
}

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

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

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

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

return *this;
}

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

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

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

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

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

return *this;
}

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

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

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

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

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

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

return sum1;
}

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

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

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

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

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

return *this;
}

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

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

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

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

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

return *this;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

R__ASSERT(this->IsValid());

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

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

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

R__ASSERT(this->IsValid());

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

return *this;
}

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

R__ASSERT(this->IsValid());

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

return *this;
}

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

R__ASSERT(this->IsValid());

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

return *this;
}

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

R__ASSERT(this->IsValid());

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

return *this;
}

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

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

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

return *this;
}

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

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

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

return *this;
}

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

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

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

return *this;
}

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

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

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

return *this;
}

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

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

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

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

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

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

return *this;
}

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

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

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

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

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

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

return *this;
}

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

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

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

return *this;
}

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

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

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

return *this;
}

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

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

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

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

return *this;
}

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

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

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

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

return *this;
}

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

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

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

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

return *this;
}

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

const TMatrixTBase<Element> *mt = row.GetMatrix();
R__ASSERT(this->IsValid());
R__ASSERT(mt->IsValid());

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

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

return *this;
}

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

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

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

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

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

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

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

return operator+(source2,source1);
}

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

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

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

return operator+(source,val);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

return operator*(val,source);
}

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

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

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

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

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

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

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

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

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator||(source2,source1);
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator<=(source2,source1);
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator<(source2,source1);
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator>(source2,source1);
}

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

TMatrixT<Element> target;

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

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator>=(source2,source1);
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

TMatrixT<Element> target;

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

target.ResizeTo(source1);

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

return target;
}

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

return operator!=(source2,source1);
}

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

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

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

return target;
}

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

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

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

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

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

return target;
}

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

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

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

return target;
}

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

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

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

return target;
}

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

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

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

return target;
}

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

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

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

return target;
}

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

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

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

return target;
}

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

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

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

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

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

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

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

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

template class TMatrixT<Float_t>;

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

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

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

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

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

template class TMatrixT<Double_t>;

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

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

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