TMatrixD

class TMatrixD : public TMatrixDBase

    protected:

      virtual 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)
              void AMultB(const TMatrixD& a, const TMatrixD& b, Int_t constr = 1)
              void AMultB(const TMatrixD& a, const TMatrixDSym& b, Int_t constr = 1)
              void AMultB(const TMatrixDSym& a, const TMatrixD& b, Int_t constr = 1)
              void AMultB(const TMatrixDSym& a, const TMatrixDSym& b, Int_t constr = 1)
              void AMultBt(const TMatrixD& a, const TMatrixD& b, Int_t constr = 1)
              void AMultBt(const TMatrixD& a, const TMatrixDSym& b, Int_t constr = 1)
              void AMultBt(const TMatrixDSym& a, const TMatrixD& b, Int_t constr = 1)
              void AMultBt(const TMatrixDSym& a, const TMatrixDSym& b, Int_t constr = 1)
              void AtMultB(const TMatrixD& a, const TMatrixD& b, Int_t constr = 1)
              void AtMultB(const TMatrixD& a, const TMatrixDSym& b, Int_t constr = 1)
              void AtMultB(const TMatrixDSym& a, const TMatrixD& b, Int_t constr = 1)
              void AtMultB(const TMatrixDSym& a, const TMatrixDSym& b, Int_t constr = 1)
              void Delete_m(Int_t size, Double_t*&)
             Int_t Memcpy_m(Double_t* newp, const Double_t* oldp, Int_t copySize, Int_t newSize, Int_t oldSize)
         Double_t* New_m(Int_t size)

    public:

                              TMatrixD()
                              TMatrixD(Int_t nrows, Int_t ncols)
                              TMatrixD(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb)
                              TMatrixD(Int_t nrows, Int_t ncols, const Double_t* data, Option_t* option = "")
                              TMatrixD(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, const Double_t* data, Option_t* option = "")
                              TMatrixD(const TMatrixD& another)
                              TMatrixD(const TMatrixF& another)
                              TMatrixD(const TMatrixDSym& another)
                              TMatrixD(const TMatrixDSparse& another)
                              TMatrixD(TMatrixDBase::EMatrixCreatorsOp1 op, const TMatrixD& prototype)
                              TMatrixD(const TMatrixD& a, TMatrixDBase::EMatrixCreatorsOp2 op, const TMatrixD& b)
                              TMatrixD(const TMatrixD& a, TMatrixDBase::EMatrixCreatorsOp2 op, const TMatrixDSym& b)
                              TMatrixD(const TMatrixDSym& a, TMatrixDBase::EMatrixCreatorsOp2 op, const TMatrixD& b)
                              TMatrixD(const TMatrixDSym& a, TMatrixDBase::EMatrixCreatorsOp2 op, const TMatrixDSym& b)
                              TMatrixD(const TMatrixDLazy& lazy_constructor)
                     TMatrixD GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t* option = "S") const
               const TMatrixD EigenVectors(TVectorD& eigenValues) const
                      virtual ~TMatrixD()
               static TClass* Class()
                 virtual void Clear(Option_t* = "")
             virtual Double_t Determinant() const
                 virtual void Determinant(Double_t& d1, Double_t& d2) const
         virtual const Int_t* GetColIndexArray() const
               virtual Int_t* GetColIndexArray()
      virtual const Double_t* GetMatrixArray() const
            virtual Double_t* GetMatrixArray()
         virtual const Int_t* GetRowIndexArray() const
               virtual Int_t* GetRowIndexArray()
        virtual TMatrixDBase& GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, TMatrixDBase& target, Option_t* option = "S") const
                    TMatrixD& Invert(Double_t* det = 0)
                    TMatrixD& InvertFast(Double_t* det = 0)
              virtual TClass* IsA() const
                         void Mult(const TMatrixD& a, const TMatrixD& b)
                         void Mult(const TMatrixD& a, const TMatrixDSym& b)
                         void Mult(const TMatrixDSym& a, const TMatrixD& b)
                    TMatrixD& NormByColumn(const TVectorD& v, Option_t* option = "D")
                    TMatrixD& NormByRow(const TVectorD& v, Option_t* option = "D")
             virtual Double_t operator()(Int_t rown, Int_t coln) const
            virtual Double_t& operator()(Int_t rown, Int_t coln)
                    TMatrixD& operator*=(Double_t val)
                    TMatrixD& operator*=(const TMatrixD& source)
                    TMatrixD& operator*=(const TMatrixDSym& source)
                    TMatrixD& operator*=(const TMatrixDDiag_const& diag)
                    TMatrixD& operator*=(const TMatrixDRow_const& row)
                    TMatrixD& operator*=(const TMatrixDColumn_const& col)
                    TMatrixD& operator+=(Double_t val)
                    TMatrixD& operator+=(const TMatrixD& source)
                    TMatrixD& operator+=(const TMatrixDSym& source)
                    TMatrixD& operator-=(Double_t val)
                    TMatrixD& operator-=(const TMatrixD& source)
                    TMatrixD& operator-=(const TMatrixDSym& source)
                    TMatrixD& operator/=(const TMatrixDDiag_const& diag)
                    TMatrixD& operator/=(const TMatrixDRow_const& row)
                    TMatrixD& operator/=(const TMatrixDColumn_const& col)
                    TMatrixD& operator=(const TMatrixD& source)
                    TMatrixD& operator=(const TMatrixF& source)
                    TMatrixD& operator=(const TMatrixDSym& source)
                    TMatrixD& operator=(const TMatrixDSparse& source)
                    TMatrixD& operator=(const TMatrixDLazy& source)
                    TMatrixD& operator=(Double_t val)
      const TMatrixDRow_const operator[](Int_t rown) const
                  TMatrixDRow operator[](Int_t rown)
                    TMatrixD& Rank1Update(const TVectorD& v, Double_t alpha = 1.0)
                    TMatrixD& Rank1Update(const TVectorD& v1, const TVectorD& v2, Double_t alpha = 1.0)
        virtual TMatrixDBase& ResizeTo(Int_t nrows, Int_t ncols, Int_t nr_nonzeros = -1)
        virtual TMatrixDBase& ResizeTo(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t nr_nonzeros = -1)
                TMatrixDBase& ResizeTo(const TMatrixD& m)
        virtual TMatrixDBase& SetColIndexArray(Int_t*)
        virtual TMatrixDBase& SetRowIndexArray(Int_t*)
        virtual TMatrixDBase& SetSub(Int_t row_lwb, Int_t col_lwb, const TMatrixDBase& source)
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)
                    TMatrixD& T()
                    TMatrixD& Transpose(const TMatrixD& source)
                    TMatrixD& Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Double_t* data)
                    TMatrixD& Use(Int_t nrows, Int_t ncols, Double_t* data)
                    TMatrixD& Use(TMatrixD& a)

Data Members

    protected:

       Double_t fDataStack[25]  ! data container
      Double_t* fElements       [fNelems] elements themselves

Class Description

                                                                      
 TMatrixD                                                             
                                                                      
 Implementation of a general matrix in the linear algebra package     
                                                                      

 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

 array elements are copied

 Create a matrix applying a specific operation to the prototype.
 Example: TMatrixD a(10,12); ...; TMatrixD b(TMatrixDBase::kTransposed, a);
 Supported operations are: kZero, kUnit, kTransposed, kInverted and kAtA.

 Create a matrix applying a specific operation to two prototypes.
 Example: TMatrixD a(10,12), b(12,5); ...; TMatrixD c(a, TMatrixDBase::kMult, b);
 Supported operations are: kMult (a*b), kTransposeMult (a'*b), kInvMult (a^(-1)*b)

 delete data pointer m, if it was assigned on the heap

 return data pointer . if requested size <= kSizeMax, assign pointer
 to the stack space

 copy copySize doubles from *oldp to *newp . However take care of the
 situation where both pointers are assigned to the same stack space

 Allocate new matrix. Arguments are number of rows, columns, row
 lowerbound (0 default) and column lowerbound (0 default).

 General matrix multiplication. Create a matrix C such that C = A * B.
 Note, matrix C is allocated for constr=1.

 Matrix multiplication, with A symmetric and B general.
 Create a matrix C such that C = A * B.
 Note, matrix C is allocated for constr=1.

 Matrix multiplication, with A general and B symmetric.
 Create a matrix C such that C = A * B.
 Note, matrix C is allocated for constr=1.

 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.
 Note, matrix C is allocated for constr=1.

 Create a matrix C such that C = A' * B. In other words,
 c[i,j] = SUM{ a[k,i] * b[k,j] }. Note, matrix C is allocated for constr=1.

 Create a matrix C such that C = A' * B. In other words,
 c[i,j] = SUM{ a[k,i] * b[k,j] }. Note, matrix C is allocated for constr=1.

 General matrix multiplication. Create a matrix C such that C = A * B^T.
 Note, matrix C is allocated for constr=1.

 Matrix multiplication, with A symmetric and B general.
 Create a matrix C such that C = A * B^T.
 Note, matrix C is allocated for constr=1.

 Get submatrix [row_lwb..row_upb][col_lwb..col_upb]; The indexing range of the
 returned matrix depends on the argument option:

 option == "S" : return [0..row_upb-row_lwb+1][0..col_upb-col_lwb+1] (default)
 else          : return [row_lwb..row_upb][col_lwb..col_upb]

 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];

 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.

 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.

 Invert the matrix and calculate its determinant

 Invert the matrix and calculate its determinant

 Transpose a matrix.

 Perform a rank 1 operation on the matrix:
     A += alpha * v * v^T

 Perform a rank 1 operation on the matrix:
     A += alpha * v1 * v2^T

 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)

 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)

 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 .

 Stream an object of class TMatrixD.

Inline Functions

                           void ~TMatrixD()
                           void AtMultB(const TMatrixDSym& a, const TMatrixD& b, Int_t constr = 1)
                           void AtMultB(const TMatrixDSym& a, const TMatrixDSym& b, Int_t constr = 1)
                           void AMultBt(const TMatrixDSym& a, const TMatrixD& b, Int_t constr = 1)
                           void AMultBt(const TMatrixDSym& a, const TMatrixDSym& b, Int_t constr = 1)
                       TMatrixD TMatrixD(const TMatrixDLazy& lazy_constructor)
                const Double_t* GetMatrixArray() const
                      Double_t* GetMatrixArray()
                   const Int_t* GetRowIndexArray() const
                         Int_t* GetRowIndexArray()
                   const Int_t* GetColIndexArray() const
                         Int_t* GetColIndexArray()
                  TMatrixDBase& SetRowIndexArray(Int_t*)
                  TMatrixDBase& SetColIndexArray(Int_t*)
                           void Clear(Option_t* = "")
                      TMatrixD& Use(Int_t nrows, Int_t ncols, Double_t* data)
                      TMatrixD& Use(TMatrixD& a)
                       TMatrixD GetSub(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Option_t* option = "S") const
                  TMatrixDBase& ResizeTo(const TMatrixD& m)
                      TMatrixD& T()
                           void Mult(const TMatrixD& a, const TMatrixD& b)
                           void Mult(const TMatrixD& a, const TMatrixDSym& b)
                           void Mult(const TMatrixDSym& a, const TMatrixD& b)
                       Double_t operator()(Int_t rown, Int_t coln) const
                      Double_t& operator()(Int_t rown, Int_t coln)
        const TMatrixDRow_const operator[](Int_t rown) const
                    TMatrixDRow operator[](Int_t rown)
                      TMatrixD& operator=(const TMatrixD& source)
                      TMatrixD& operator=(const TMatrixF& source)
                      TMatrixD& operator=(const TMatrixDSym& source)
                      TMatrixD& operator=(const TMatrixDSparse& source)
                      TMatrixD& operator=(const TMatrixDLazy& source)
                      TMatrixD& operator=(Double_t val)
                      TMatrixD& operator-=(Double_t val)
                      TMatrixD& operator+=(Double_t val)
                      TMatrixD& operator*=(Double_t val)
                      TMatrixD& operator+=(const TMatrixD& source)
                      TMatrixD& operator+=(const TMatrixDSym& source)
                      TMatrixD& operator-=(const TMatrixD& source)
                      TMatrixD& operator-=(const TMatrixDSym& source)
                      TMatrixD& operator*=(const TMatrixD& source)
                      TMatrixD& operator*=(const TMatrixDSym& source)
                      TMatrixD& operator*=(const TMatrixDDiag_const& diag)
                      TMatrixD& operator/=(const TMatrixDDiag_const& diag)
                      TMatrixD& operator*=(const TMatrixDRow_const& row)
                      TMatrixD& operator/=(const TMatrixDRow_const& row)
                      TMatrixD& operator*=(const TMatrixDColumn_const& col)
                      TMatrixD& operator/=(const TMatrixDColumn_const& col)
                        TClass* Class()
                        TClass* IsA() const
                           void ShowMembers(TMemberInspector& insp, char* parent)
                           void StreamerNVirtual(TBuffer& b)