TDecompBK

class TDecompBK : public TDecompBase

    protected:

      virtual const TMatrixDBase& GetDecompMatrix() const

    public:

                       TDecompBK()
                       TDecompBK(Int_t nrows)
                       TDecompBK(Int_t row_lwb, Int_t row_upb)
                       TDecompBK(const TMatrixDSym& m, Double_t tol = 0.0)
                       TDecompBK(const TDecompBK& another)
               virtual ~TDecompBK()
        static TClass* Class()
        virtual Bool_t Decompose()
          virtual void Det(Double_t&, Double_t&)
         virtual Int_t GetNcols() const
         virtual Int_t GetNrows() const
       const TMatrixD& GetU() const
                  void Invert(TMatrixDSym& inv)
           TMatrixDSym Invert()
       virtual TClass* IsA() const
            TDecompBK& operator=(const TDecompBK& source)
          virtual void Print(Option_t* opt = "") const
          virtual void SetMatrix(const TMatrixDSym& 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 fNIpiv  size of row permutation index
        Int_t* fIpiv   [fNIpiv] row permutation index
      TMatrixD fU      decomposed matrix so that a = u d u^T

Class Description

                                                                       
 The Bunch-Kaufman diagonal pivoting method decomposes a real          
 symmetric matrix A using                                              
                                                                       
     A = U*D*U^T                                                       
                                                                       
  where U is a product of permutation and unit upper triangular        
  matrices, U^T is the transpose of U, and D is symmetric and block    
  diagonal with 1-by-1 and 2-by-2 diagonal blocks.                     
                                                                       
     U = P(n-1)*U(n-1)* ... *P(k)U(k)* ...,                            
  i.e., U is a product of terms P(k)*U(k), where k decreases from n-1  
  to 0 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as    
  defined by IPIV(k), and U(k) is a unit upper triangular matrix, such 
  that if the diagonal block D(k) is of order s (s = 1 or 2), then     
                                                                       
             (   I    v    0   )   k-s                                 
     U(k) =  (   0    I    0   )   s                                   
             (   0    0    I   )   n-k                                 
                k-s   s   n-k                                          
                                                                       
  If s = 1, D(k) overwrites A(k,k), and v overwrites A(0:k-1,k).       
  If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
  and A(k,k), and v overwrites A(0:k-2,k-1:k).                         
                                                                       
 fU contains on entry the symmetric matrix A of which only the upper   
 triangular part is referenced . On exit fU contains the block diagonal
 matrix D and the multipliers used to obtain the factor U, see above . 
                                                                       
 fIpiv if dimension n contains details of the interchanges and the     
 the block structure of D . if (fIPiv(k) > 0, then rows and columns k  
 and fIPiv(k) were interchanged and D(k,k) is a 1-by-1 diagonal block. 
 If IPiv(k) = fIPiv(k-1) < 0, rows and columns k-1 and -IPiv(k) were   
 interchanged and D(k-1:k,k-1:k) is a 2-by-2 diagonal block.           
                                                                       

 Solve Ax=b assuming the BK form of A is stored in fU . Solution returned in b.

 Solve Ax=b assuming the BK form of A is stored in fU . Solution returned in b.

 For a symmetric matrix A(m,m), its inverse A_inv(m,m) is returned .

 For a symmetric matrix A(m,m), its inverse A_inv(m,m) is returned .

Inline Functions

                       void ~TDecompBK()
        const TMatrixDBase& GetDecompMatrix() const
                      Int_t GetNrows() const
                      Int_t GetNcols() const
            const TMatrixD& GetU() const
                     Bool_t Solve(TMatrixDColumn& b)
                     Bool_t TransSolve(TVectorD& b)
                   TVectorD TransSolve(const TVectorD& b, Bool_t& ok)
                     Bool_t TransSolve(TMatrixDColumn& b)
                       void Det(Double_t&, Double_t&)
                 TDecompBK& operator=(const TDecompBK& source)
                    TClass* Class()
                    TClass* IsA() const
                       void ShowMembers(TMemberInspector& insp, char* parent)
                       void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)