library: libMatrix #include "TDecompLU.h"

# TDecompLU

class description - source file - inheritance tree (.ps)

## class TDecompLU : public TDecompBase

| Inheritance Chart:

`TObject`

<-

`TDecompBase`

<-

`TDecompLU`

        protected:

          virtual const TMatrixDBase& GetDecompMatrix() const

        public:

                           TDecompLU()
                           TDecompLU(Int_t nrows)
                           TDecompLU(Int_t row_lwb, Int_t row_upb)
                           TDecompLU(const TMatrixD& m, Double_t tol = 0.0, Int_t implicit = 1)
                           TDecompLU(const TDecompLU& another)
                   virtual ~TDecompLU()
            static TClass* Class()
          virtual Double_t Condition()
            virtual Bool_t Decompose()
             static Bool_t DecomposeLUCrout(TMatrixD& lu, Int_t* index, Double_t& sign, Double_t tol, Int_t& nrZeros)
             static Bool_t DecomposeLUGauss(TMatrixD& lu, Int_t* index, Double_t& sign, Double_t tol, Int_t& nrZeros)
              virtual void Det(Double_t& d1, Double_t& d2)
                 TMatrixD& GetLU()
            const TMatrixD GetMatrix() const
             virtual Int_t GetNcols() const
             virtual Int_t GetNrows() const
             static Bool_t InvertLU(TMatrixD& lu, Int_t* index, Double_t tol)
           virtual TClass* IsA() const
                TDecompLU& operator=(const TDecompLU& source)
              virtual void Print(Option_t* opt) const
              virtual void SetMatrix(const TMatrixD& a)
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
            virtual Bool_t Solve(TVectorD& b)
          virtual TVectorD Solve(const TVectorD& b, Bool_t& ok)
            virtual Bool_t Solve(TMatrixDColumn& b)
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
            virtual Bool_t TransSolve(TVectorD& b)
          virtual TVectorD TransSolve(const TVectorD& b, Bool_t& ok)
            virtual Bool_t TransSolve(TMatrixDColumn& b)

### Data Members

        protected:

             Int_t fImplicitPivot  control to determine implicit row scale before
             Int_t fNIndex         size of row permutation index
            Int_t* fIndex          [fNIndex] row permutation index
          Double_t fSign           = +/- 1 reflecting even/odd row permutations, resp.
          TMatrixD fLU             decomposed matrix so that a = l u where

## Class Description

     LU Decomposition class

     Decompose  a general n x n matrix A into P A = L U

     where P is a permutation matrix, L is unit lower triangular and U
     is upper triangular.
     L is stored in the strict lower triangular part of the matrix fLU.
     The diagonal elements of L are unity and are not stored.
     U is stored in the diagonal and upper triangular part of the matrix
     fU.
     P is stored in the index array fIndex : j = fIndex[i] indicates that
     row j and row i should be swapped .

     fSign gives the sign of the permutation, (-1)^n, where n is the
     number of interchanges in the permutation.

     The decomposition fails if a diagonal element of abs(fLU) is == 0,
     The matrix fUL is made invalid

TDecompLU()

TDecompLU(Int_t nrows)

TDecompLU(Int_t row_lwb,Int_t row_upb)

TDecompLU(const TMatrixD &a,Double_t tol,Int_t implicit)

TDecompLU(const TDecompLU &another) : TDecompBase(another)

Bool_t Decompose()

const TMatrixD GetMatrix()

     Reconstruct the original matrix using the decomposition parts

void SetMatrix(const TMatrixD &a)

Bool_t Solve(TVectorD &b)

     Solve Ax=b assuming the LU form of A is stored in fLU, but assume b has *not*
     been transformed.  Solution returned in b.

TVectorD Solve(const TVectorD &b,Bool_t &ok)

     Solve Ax=b assuming the LU form of A is stored in fLU, but assume b has *not*
     been transformed.

Bool_t Solve(TMatrixDColumn &cb)

     Solve Ax=b assuming the LU form of A is stored in fLU, but assume b has *not*
     been transformed.  Solution returned in b.

Bool_t TransSolve(TVectorD &b)

     Solve A^T x=b assuming the LU form of A^T is stored in fLU, but assume b has *not*
     been transformed.  Solution returned in b.

TVectorD TransSolve(const TVectorD &b,Bool_t &ok)

     Solve A^T x=b assuming the LU form of A^T is stored in fLU, but assume b has *not*
     been transformed.

Bool_t TransSolve(TMatrixDColumn &cb)

     Solve A^T x=b assuming the LU form of A^T is stored in fLU, but assume b has *not*
     been transformed.  Solution returned in b.

Double_t Condition()

void Det(Double_t &d1,Double_t &d2)

void Print(Option_t *opt) const

Bool_t DecomposeLUCrout(TMatrixD &lu,Int_t *index,Double_t &sign, Double_t tol,Int_t &nrZeros)

     Crout/Doolittle algorithm of LU decomposing a square matrix, with implicit partial
     pivoting.  The decomposition is stored in fLU: U is explicit in the upper triag
     and L is in multiplier form in the subdiagionals .
     Row permutations are mapped out in fIndex. fSign, used for calculating the
     determinant, is +/- 1 for even/odd row permutations. .

Bool_t DecomposeLUGauss(TMatrixD &lu,Int_t *index,Double_t &sign, Double_t tol,Int_t &nrZeros)

     LU decomposition using Gaussain Elimination with partial pivoting (See Golub &
     Van Loan, Matrix Computations, Algorithm 3.4.1) of a square matrix .
     The decomposition is stored in fLU: U is explicit in the upper triag and L is in
     multiplier form in the subdiagionals . Row permutations are mapped out in fIndex.
     fSign, used for calculating the determinant, is +/- 1 for even/odd row permutations.
     Since this algorithm uses partial pivoting without scaling like in Crout/Doolitle.
     it is somewhat faster but less precise .

Bool_t InvertLU(TMatrixD &lu,Int_t *index,Double_t tol)

     Calculate matrix inversion through in place forward/backward substitution

### Inline Functions

                           void ~TDecompLU()
            const TMatrixDBase& GetDecompMatrix() const
                          Int_t GetNrows() const
                          Int_t GetNcols() const
                      TMatrixD& GetLU()
                     TDecompLU& operator=(const TDecompLU& source)
                        TClass* Class()
                        TClass* IsA() const
                           void ShowMembers(TMemberInspector& insp, char* parent)
                           void Streamer(TBuffer& b)
                           void StreamerNVirtual(TBuffer& b)

Last update: root/matrix:$Name: $:$Id: TDecompLU.cxx,v 1.13 2004/06/13 14:53:15 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *