ROOT logo
// @(#)root/matrix:$Id: TMatrixT.h 34744 2010-08-07 06:16:36Z brun $
// Authors: Fons Rademakers, Eddy Offermann   Nov 2003

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

#ifndef ROOT_TMatrixT
#define ROOT_TMatrixT

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

#ifndef ROOT_TMatrixTBase
#include "TMatrixTBase.h"
#endif
#ifndef ROOT_TMatrixTUtils
#include "TMatrixTUtils.h"
#endif

#ifdef CBLAS
#include <vecLib/vBLAS.h>
//#include <cblas.h>
#endif

template<class Element> class TMatrixTSym;
template<class Element> class TMatrixTSparse;
template<class Element> class TMatrixTLazy;

template<class Element> class TMatrixT : public TMatrixTBase<Element> {

protected:

   Element  fDataStack[TMatrixTBase<Element>::kSizeMax]; //! data container
   Element *fElements;                                   //[fNelems] elements themselves

   Element *New_m   (Int_t size);
   void     Delete_m(Int_t size,Element*&);
   Int_t    Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
                      Int_t newSize,Int_t oldSize);
   void     Allocate(Int_t nrows,Int_t ncols,Int_t row_lwb = 0,Int_t col_lwb = 0,Int_t init = 0,
                     Int_t /*nr_nonzeros*/ = -1);

public:

   enum {kWorkMax = 100};
   enum EMatrixCreatorsOp1 { kZero,kUnit,kTransposed,kInverted,kAtA };
   enum EMatrixCreatorsOp2 { kMult,kTransposeMult,kInvMult,kMultTranspose,kPlus,kMinus };

   TMatrixT(): fElements(0) { }
   TMatrixT(Int_t nrows,Int_t ncols);
   TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
   TMatrixT(Int_t nrows,Int_t ncols,const Element *data,Option_t *option="");
   TMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data,Option_t *option="");
   TMatrixT(const TMatrixT      <Element> &another);
   TMatrixT(const TMatrixTSym   <Element> &another);
   TMatrixT(const TMatrixTSparse<Element> &another);
   template <class Element2> TMatrixT(const TMatrixT<Element2> &another): fElements(0)
   {
      R__ASSERT(another.IsValid());
      Allocate(another.GetNrows(),another.GetNcols(),another.GetRowLwb(),another.GetColLwb());
      *this = another;
   }

   TMatrixT(EMatrixCreatorsOp1 op,const TMatrixT<Element> &prototype);
   TMatrixT(const TMatrixT    <Element> &a,EMatrixCreatorsOp2 op,const TMatrixT   <Element> &b);
   TMatrixT(const TMatrixT    <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b);
   TMatrixT(const TMatrixTSym <Element> &a,EMatrixCreatorsOp2 op,const TMatrixT   <Element> &b);
   TMatrixT(const TMatrixTSym <Element> &a,EMatrixCreatorsOp2 op,const TMatrixTSym<Element> &b);
   TMatrixT(const TMatrixTLazy<Element> &lazy_constructor);

   virtual ~TMatrixT() { Clear(); }

   // Elementary constructors

   void Plus (const TMatrixT   <Element> &a,const TMatrixT   <Element> &b);
   void Plus (const TMatrixT   <Element> &a,const TMatrixTSym<Element> &b);
   void Plus (const TMatrixTSym<Element> &a,const TMatrixT   <Element> &b) { Plus(b,a); }

   void Minus(const TMatrixT   <Element> &a,const TMatrixT   <Element> &b);
   void Minus(const TMatrixT   <Element> &a,const TMatrixTSym<Element> &b);
   void Minus(const TMatrixTSym<Element> &a,const TMatrixT   <Element> &b) { Minus(b,a); }

   void Mult (const TMatrixT   <Element> &a,const TMatrixT   <Element> &b);
   void Mult (const TMatrixT   <Element> &a,const TMatrixTSym<Element> &b);
   void Mult (const TMatrixTSym<Element> &a,const TMatrixT   <Element> &b);
   void Mult (const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b);

   void TMult(const TMatrixT   <Element> &a,const TMatrixT   <Element> &b);
   void TMult(const TMatrixT   <Element> &a,const TMatrixTSym<Element> &b);
   void TMult(const TMatrixTSym<Element> &a,const TMatrixT   <Element> &b) { Mult(a,b); }
   void TMult(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }

   void MultT(const TMatrixT   <Element> &a,const TMatrixT   <Element> &b);
   void MultT(const TMatrixT   <Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }
   void MultT(const TMatrixTSym<Element> &a,const TMatrixT   <Element> &b);
   void MultT(const TMatrixTSym<Element> &a,const TMatrixTSym<Element> &b) { Mult(a,b); }

   virtual const Element *GetMatrixArray  () const;
   virtual       Element *GetMatrixArray  ();
   virtual const Int_t   *GetRowIndexArray() const { return 0; }
   virtual       Int_t   *GetRowIndexArray()       { return 0; }
   virtual const Int_t   *GetColIndexArray() const { return 0; }
   virtual       Int_t   *GetColIndexArray()       { return 0; }

   virtual       TMatrixTBase<Element> &SetRowIndexArray(Int_t * /*data*/) { MayNotUse("SetRowIndexArray(Int_t *)"); return *this; }
   virtual       TMatrixTBase<Element> &SetColIndexArray(Int_t * /*data*/) { MayNotUse("SetColIndexArray(Int_t *)"); return *this; }

   virtual void Clear(Option_t * /*option*/ ="") { if (this->fIsOwner) Delete_m(this->fNelems,fElements);
                                                   else fElements = 0;  this->fNelems = 0; }

           TMatrixT    <Element> &Use     (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Element *data);
   const   TMatrixT    <Element> &Use     (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,const Element *data) const
                                            { return (const TMatrixT<Element>&)
                                                     ((const_cast<TMatrixT<Element> *>(this))->Use(row_lwb,row_upb,col_lwb,col_upb, const_cast<Element *>(data))); }
           TMatrixT    <Element> &Use     (Int_t nrows,Int_t ncols,Element *data);
   const   TMatrixT    <Element> &Use     (Int_t nrows,Int_t ncols,const Element *data) const;
           TMatrixT    <Element> &Use     (TMatrixT<Element> &a);
   const   TMatrixT    <Element> &Use     (const TMatrixT<Element> &a) const;

   virtual TMatrixTBase<Element> &GetSub  (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                           TMatrixTBase<Element> &target,Option_t *option="S") const;
           TMatrixT    <Element>  GetSub  (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Option_t *option="S") const;
   virtual TMatrixTBase<Element> &SetSub  (Int_t row_lwb,Int_t col_lwb,const TMatrixTBase<Element> &source);

   virtual TMatrixTBase<Element> &ResizeTo(Int_t nrows,Int_t ncols,Int_t /*nr_nonzeros*/ =-1);
   virtual TMatrixTBase<Element> &ResizeTo(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,Int_t /*nr_nonzeros*/ =-1);
   inline  TMatrixTBase<Element> &ResizeTo(const TMatrixT<Element> &m) {
                                            return ResizeTo(m.GetRowLwb(),m.GetRowUpb(),m.GetColLwb(),m.GetColUpb());
                                 }

   virtual Double_t Determinant  () const;
   virtual void     Determinant  (Double_t &d1,Double_t &d2) const;

           TMatrixT<Element> &Invert      (Double_t *det=0);
           TMatrixT<Element> &InvertFast  (Double_t *det=0);
           TMatrixT<Element> &Transpose   (const TMatrixT<Element> &source);
   inline  TMatrixT<Element> &T           () { return this->Transpose(*this); }
           TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v,Element alpha=1.0);
           TMatrixT<Element> &Rank1Update (const TVectorT<Element> &v1,const TVectorT<Element> &v2,Element alpha=1.0);
           Element            Similarity  (const TVectorT<Element> &v) const;

   TMatrixT<Element> &NormByColumn(const TVectorT<Element> &v,Option_t *option="D");
   TMatrixT<Element> &NormByRow   (const TVectorT<Element> &v,Option_t *option="D");

   // Either access a_ij as a(i,j)
   inline       Element                     operator()(Int_t rown,Int_t coln) const;
   inline       Element                    &operator()(Int_t rown,Int_t coln);

   // or as a[i][j]
   inline const TMatrixTRow_const<Element>  operator[](Int_t rown) const { return TMatrixTRow_const<Element>(*this,rown); }
   inline       TMatrixTRow      <Element>  operator[](Int_t rown)       { return TMatrixTRow      <Element>(*this,rown); }

   TMatrixT<Element> &operator= (const TMatrixT      <Element> &source);
   TMatrixT<Element> &operator= (const TMatrixTSym   <Element> &source);
   TMatrixT<Element> &operator= (const TMatrixTSparse<Element> &source);
   TMatrixT<Element> &operator= (const TMatrixTLazy  <Element> &source);
   template <class Element2> TMatrixT<Element> &operator= (const TMatrixT<Element2> &source)
   {
      if (!AreCompatible(*this,source)) {
         Error("operator=(const TMatrixT2 &)","matrices not compatible");
         return *this;
      }

     TObject::operator=(source);
     const Element2 * const ps = source.GetMatrixArray();
           Element  * const pt = this->GetMatrixArray();
     for (Int_t i = 0; i < this->fNelems; i++)
        pt[i] = ps[i];
     this->fTol = source.GetTol();
     return *this;
   }

   TMatrixT<Element> &operator= (Element val);
   TMatrixT<Element> &operator-=(Element val);
   TMatrixT<Element> &operator+=(Element val);
   TMatrixT<Element> &operator*=(Element val);

   TMatrixT<Element> &operator+=(const TMatrixT   <Element> &source);
   TMatrixT<Element> &operator+=(const TMatrixTSym<Element> &source);
   TMatrixT<Element> &operator-=(const TMatrixT   <Element> &source);
   TMatrixT<Element> &operator-=(const TMatrixTSym<Element> &source);

   TMatrixT<Element> &operator*=(const TMatrixT            <Element> &source);
   TMatrixT<Element> &operator*=(const TMatrixTSym         <Element> &source);
   TMatrixT<Element> &operator*=(const TMatrixTDiag_const  <Element> &diag);
   TMatrixT<Element> &operator/=(const TMatrixTDiag_const  <Element> &diag);
   TMatrixT<Element> &operator*=(const TMatrixTRow_const   <Element> &row);
   TMatrixT<Element> &operator/=(const TMatrixTRow_const   <Element> &row);
   TMatrixT<Element> &operator*=(const TMatrixTColumn_const<Element> &col);
   TMatrixT<Element> &operator/=(const TMatrixTColumn_const<Element> &col);

   const TMatrixT<Element> EigenVectors(TVectorT<Element> &eigenValues) const;

   ClassDef(TMatrixT,4) // Template of General Matrix class
};

template <class Element> inline const Element           *TMatrixT<Element>::GetMatrixArray() const { return fElements; }
template <class Element> inline       Element           *TMatrixT<Element>::GetMatrixArray()       { return fElements; }

template <class Element> inline       TMatrixT<Element> &TMatrixT<Element>::Use           (Int_t nrows,Int_t ncols,Element *data)
                                                                                          { return Use(0,nrows-1,0,ncols-1,data); }
template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use           (Int_t nrows,Int_t ncols,const Element *data) const
                                                                                          { return Use(0,nrows-1,0,ncols-1,data); }
template <class Element> inline       TMatrixT<Element> &TMatrixT<Element>::Use           (TMatrixT &a)
                                                                                          {
                                                                                            R__ASSERT(a.IsValid());
                                                                                            return Use(a.GetRowLwb(),a.GetRowUpb(),
                                                                                                       a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
                                                                                          }
template <class Element> inline const TMatrixT<Element> &TMatrixT<Element>::Use           (const TMatrixT &a) const
                                                                                          {
                                                                                            R__ASSERT(a.IsValid());
                                                                                            return Use(a.GetRowLwb(),a.GetRowUpb(),
                                                                                                       a.GetColLwb(),a.GetColUpb(),a.GetMatrixArray());
                                                                                          }

template <class Element> inline       TMatrixT<Element>  TMatrixT<Element>::GetSub        (Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb,
                                                                                           Option_t *option) const
                                                                                          {
                                                                                            TMatrixT tmp;
                                                                                            this->GetSub(row_lwb,row_upb,col_lwb,col_upb,tmp,option);
                                                                                            return tmp;
                                                                                          }

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

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

template <class Element> TMatrixT<Element>  operator+  (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator+  (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator+  (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator+  (const TMatrixT   <Element> &source ,      Element               val    );
template <class Element> TMatrixT<Element>  operator+  (      Element               val    ,const TMatrixT   <Element> &source );
template <class Element> TMatrixT<Element>  operator-  (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator-  (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator-  (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator-  (const TMatrixT   <Element> &source ,      Element               val    );
template <class Element> TMatrixT<Element>  operator-  (      Element               val    ,const TMatrixT   <Element> &source );
template <class Element> TMatrixT<Element>  operator*  (      Element               val    ,const TMatrixT   <Element> &source );
template <class Element> TMatrixT<Element>  operator*  (const TMatrixT   <Element> &source ,      Element               val    );
template <class Element> TMatrixT<Element>  operator*  (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator*  (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator*  (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator*  (const TMatrixTSym<Element> &source1,const TMatrixTSym<Element> &source2);
// Preventing warnings with -Weffc++ in GCC since overloading the || and && operators was a design choice.
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
template <class Element> TMatrixT<Element>  operator&& (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator&& (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator&& (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator|| (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator|| (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator|| (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic pop
#endif
template <class Element> TMatrixT<Element>  operator>  (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator>  (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator>  (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator>= (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator>= (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator>= (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator<= (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator<= (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator<= (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator<  (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator<  (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator<  (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator!= (const TMatrixT   <Element> &source1,const TMatrixT   <Element> &source2);
template <class Element> TMatrixT<Element>  operator!= (const TMatrixT   <Element> &source1,const TMatrixTSym<Element> &source2);
template <class Element> TMatrixT<Element>  operator!= (const TMatrixTSym<Element> &source1,const TMatrixT   <Element> &source2);

template <class Element> TMatrixT<Element> &Add        (TMatrixT<Element> &target,      Element               scalar,const TMatrixT   <Element> &source);
template <class Element> TMatrixT<Element> &Add        (TMatrixT<Element> &target,      Element               scalar,const TMatrixTSym<Element> &source);
template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixT   <Element> &source);
template <class Element> TMatrixT<Element> &ElementMult(TMatrixT<Element> &target,const TMatrixTSym<Element> &source);
template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixT   <Element> &source);
template <class Element> TMatrixT<Element> &ElementDiv (TMatrixT<Element> &target,const TMatrixTSym<Element> &source);

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);
template <class Element> void AtMultB(const Element * const ap,Int_t ncolsa,
                                      const Element * const bp,Int_t nb,Int_t ncolsb,Element *cp);
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);

#endif
 TMatrixT.h:1
 TMatrixT.h:2
 TMatrixT.h:3
 TMatrixT.h:4
 TMatrixT.h:5
 TMatrixT.h:6
 TMatrixT.h:7
 TMatrixT.h:8
 TMatrixT.h:9
 TMatrixT.h:10
 TMatrixT.h:11
 TMatrixT.h:12
 TMatrixT.h:13
 TMatrixT.h:14
 TMatrixT.h:15
 TMatrixT.h:16
 TMatrixT.h:17
 TMatrixT.h:18
 TMatrixT.h:19
 TMatrixT.h:20
 TMatrixT.h:21
 TMatrixT.h:22
 TMatrixT.h:23
 TMatrixT.h:24
 TMatrixT.h:25
 TMatrixT.h:26
 TMatrixT.h:27
 TMatrixT.h:28
 TMatrixT.h:29
 TMatrixT.h:30
 TMatrixT.h:31
 TMatrixT.h:32
 TMatrixT.h:33
 TMatrixT.h:34
 TMatrixT.h:35
 TMatrixT.h:36
 TMatrixT.h:37
 TMatrixT.h:38
 TMatrixT.h:39
 TMatrixT.h:40
 TMatrixT.h:41
 TMatrixT.h:42
 TMatrixT.h:43
 TMatrixT.h:44
 TMatrixT.h:45
 TMatrixT.h:46
 TMatrixT.h:47
 TMatrixT.h:48
 TMatrixT.h:49
 TMatrixT.h:50
 TMatrixT.h:51
 TMatrixT.h:52
 TMatrixT.h:53
 TMatrixT.h:54
 TMatrixT.h:55
 TMatrixT.h:56
 TMatrixT.h:57
 TMatrixT.h:58
 TMatrixT.h:59
 TMatrixT.h:60
 TMatrixT.h:61
 TMatrixT.h:62
 TMatrixT.h:63
 TMatrixT.h:64
 TMatrixT.h:65
 TMatrixT.h:66
 TMatrixT.h:67
 TMatrixT.h:68
 TMatrixT.h:69
 TMatrixT.h:70
 TMatrixT.h:71
 TMatrixT.h:72
 TMatrixT.h:73
 TMatrixT.h:74
 TMatrixT.h:75
 TMatrixT.h:76
 TMatrixT.h:77
 TMatrixT.h:78
 TMatrixT.h:79
 TMatrixT.h:80
 TMatrixT.h:81
 TMatrixT.h:82
 TMatrixT.h:83
 TMatrixT.h:84
 TMatrixT.h:85
 TMatrixT.h:86
 TMatrixT.h:87
 TMatrixT.h:88
 TMatrixT.h:89
 TMatrixT.h:90
 TMatrixT.h:91
 TMatrixT.h:92
 TMatrixT.h:93
 TMatrixT.h:94
 TMatrixT.h:95
 TMatrixT.h:96
 TMatrixT.h:97
 TMatrixT.h:98
 TMatrixT.h:99
 TMatrixT.h:100
 TMatrixT.h:101
 TMatrixT.h:102
 TMatrixT.h:103
 TMatrixT.h:104
 TMatrixT.h:105
 TMatrixT.h:106
 TMatrixT.h:107
 TMatrixT.h:108
 TMatrixT.h:109
 TMatrixT.h:110
 TMatrixT.h:111
 TMatrixT.h:112
 TMatrixT.h:113
 TMatrixT.h:114
 TMatrixT.h:115
 TMatrixT.h:116
 TMatrixT.h:117
 TMatrixT.h:118
 TMatrixT.h:119
 TMatrixT.h:120
 TMatrixT.h:121
 TMatrixT.h:122
 TMatrixT.h:123
 TMatrixT.h:124
 TMatrixT.h:125
 TMatrixT.h:126
 TMatrixT.h:127
 TMatrixT.h:128
 TMatrixT.h:129
 TMatrixT.h:130
 TMatrixT.h:131
 TMatrixT.h:132
 TMatrixT.h:133
 TMatrixT.h:134
 TMatrixT.h:135
 TMatrixT.h:136
 TMatrixT.h:137
 TMatrixT.h:138
 TMatrixT.h:139
 TMatrixT.h:140
 TMatrixT.h:141
 TMatrixT.h:142
 TMatrixT.h:143
 TMatrixT.h:144
 TMatrixT.h:145
 TMatrixT.h:146
 TMatrixT.h:147
 TMatrixT.h:148
 TMatrixT.h:149
 TMatrixT.h:150
 TMatrixT.h:151
 TMatrixT.h:152
 TMatrixT.h:153
 TMatrixT.h:154
 TMatrixT.h:155
 TMatrixT.h:156
 TMatrixT.h:157
 TMatrixT.h:158
 TMatrixT.h:159
 TMatrixT.h:160
 TMatrixT.h:161
 TMatrixT.h:162
 TMatrixT.h:163
 TMatrixT.h:164
 TMatrixT.h:165
 TMatrixT.h:166
 TMatrixT.h:167
 TMatrixT.h:168
 TMatrixT.h:169
 TMatrixT.h:170
 TMatrixT.h:171
 TMatrixT.h:172
 TMatrixT.h:173
 TMatrixT.h:174
 TMatrixT.h:175
 TMatrixT.h:176
 TMatrixT.h:177
 TMatrixT.h:178
 TMatrixT.h:179
 TMatrixT.h:180
 TMatrixT.h:181
 TMatrixT.h:182
 TMatrixT.h:183
 TMatrixT.h:184
 TMatrixT.h:185
 TMatrixT.h:186
 TMatrixT.h:187
 TMatrixT.h:188
 TMatrixT.h:189
 TMatrixT.h:190
 TMatrixT.h:191
 TMatrixT.h:192
 TMatrixT.h:193
 TMatrixT.h:194
 TMatrixT.h:195
 TMatrixT.h:196
 TMatrixT.h:197
 TMatrixT.h:198
 TMatrixT.h:199
 TMatrixT.h:200
 TMatrixT.h:201
 TMatrixT.h:202
 TMatrixT.h:203
 TMatrixT.h:204
 TMatrixT.h:205
 TMatrixT.h:206
 TMatrixT.h:207
 TMatrixT.h:208
 TMatrixT.h:209
 TMatrixT.h:210
 TMatrixT.h:211
 TMatrixT.h:212
 TMatrixT.h:213
 TMatrixT.h:214
 TMatrixT.h:215
 TMatrixT.h:216
 TMatrixT.h:217
 TMatrixT.h:218
 TMatrixT.h:219
 TMatrixT.h:220
 TMatrixT.h:221
 TMatrixT.h:222
 TMatrixT.h:223
 TMatrixT.h:224
 TMatrixT.h:225
 TMatrixT.h:226
 TMatrixT.h:227
 TMatrixT.h:228
 TMatrixT.h:229
 TMatrixT.h:230
 TMatrixT.h:231
 TMatrixT.h:232
 TMatrixT.h:233
 TMatrixT.h:234
 TMatrixT.h:235
 TMatrixT.h:236
 TMatrixT.h:237
 TMatrixT.h:238
 TMatrixT.h:239
 TMatrixT.h:240
 TMatrixT.h:241
 TMatrixT.h:242
 TMatrixT.h:243
 TMatrixT.h:244
 TMatrixT.h:245
 TMatrixT.h:246
 TMatrixT.h:247
 TMatrixT.h:248
 TMatrixT.h:249
 TMatrixT.h:250
 TMatrixT.h:251
 TMatrixT.h:252
 TMatrixT.h:253
 TMatrixT.h:254
 TMatrixT.h:255
 TMatrixT.h:256
 TMatrixT.h:257
 TMatrixT.h:258
 TMatrixT.h:259
 TMatrixT.h:260
 TMatrixT.h:261
 TMatrixT.h:262
 TMatrixT.h:263
 TMatrixT.h:264
 TMatrixT.h:265
 TMatrixT.h:266
 TMatrixT.h:267
 TMatrixT.h:268
 TMatrixT.h:269
 TMatrixT.h:270
 TMatrixT.h:271
 TMatrixT.h:272
 TMatrixT.h:273
 TMatrixT.h:274
 TMatrixT.h:275
 TMatrixT.h:276
 TMatrixT.h:277
 TMatrixT.h:278
 TMatrixT.h:279
 TMatrixT.h:280
 TMatrixT.h:281
 TMatrixT.h:282
 TMatrixT.h:283
 TMatrixT.h:284
 TMatrixT.h:285
 TMatrixT.h:286
 TMatrixT.h:287
 TMatrixT.h:288
 TMatrixT.h:289
 TMatrixT.h:290
 TMatrixT.h:291
 TMatrixT.h:292
 TMatrixT.h:293
 TMatrixT.h:294
 TMatrixT.h:295
 TMatrixT.h:296
 TMatrixT.h:297
 TMatrixT.h:298
 TMatrixT.h:299
 TMatrixT.h:300
 TMatrixT.h:301
 TMatrixT.h:302
 TMatrixT.h:303
 TMatrixT.h:304
 TMatrixT.h:305
 TMatrixT.h:306
 TMatrixT.h:307
 TMatrixT.h:308
 TMatrixT.h:309
 TMatrixT.h:310
 TMatrixT.h:311
 TMatrixT.h:312
 TMatrixT.h:313
 TMatrixT.h:314
 TMatrixT.h:315
 TMatrixT.h:316
 TMatrixT.h:317
 TMatrixT.h:318
 TMatrixT.h:319
 TMatrixT.h:320
 TMatrixT.h:321
 TMatrixT.h:322
 TMatrixT.h:323
 TMatrixT.h:324
 TMatrixT.h:325
 TMatrixT.h:326
 TMatrixT.h:327