class TDecompSVD: public TDecompBase

 Constructor for (nrows x ncols) matrix

 Constructor for ([row_lwb..row_upb] x [col_lwb..col_upb]) matrix

 Constructor for general matrix A .

 Copy constructor

 SVD decomposition of matrix
 If the decomposition succeeds, bit kDecomposed is set , otherwise kSingular

 Bidiagonalize the (m x n) - matrix a (stored in v) through a series of Householder
 transformations applied to the left (Q^T) and to the right (H) of a ,
 so that A = Q . C . H^T with matrix C bidiagonal. Q and H are orthogonal matrices .

 Output:
   v     - (n x n) - matrix H in the (n x n) part of v
   u     - (m x m) - matrix Q^T
   sDiag - diagonal of the (m x n) C
   oDiag - off-diagonal elements of matrix C

  Test code for the output:
    const Int_t nRow = v.GetNrows();
    const Int_t nCol = v.GetNcols();
    TMatrixD H(v); H.ResizeTo(nCol,nCol);
    TMatrixD E1(nCol,nCol); E1.UnitMatrix();
    TMatrixD Ht(TMatrixDBase::kTransposed,H);
    Bool_t ok = kTRUE;
    ok &= VerifyMatrixIdentity(Ht * H,E1,kTRUE,1.0e-13);
    ok &= VerifyMatrixIdentity(H * Ht,E1,kTRUE,1.0e-13);
    TMatrixD E2(nRow,nRow); E2.UnitMatrix();
    TMatrixD Qt(u);
    TMatrixD Q(TMatrixDBase::kTransposed,Qt);
    ok &= VerifyMatrixIdentity(Q * Qt,E2,kTRUE,1.0e-13);
    TMatrixD C(nRow,nCol);
    TMatrixDDiag(C) = sDiag;
    for (Int_t i = 0; i < nCol-1; i++)
      C(i,i+1) = oDiag(i+1);
    TMatrixD A = Q*C*Ht;
    ok &= VerifyMatrixIdentity(A,a,kTRUE,1.0e-13);

 Diagonalizes in an iterative fashion the bidiagonal matrix C as described through
 sDiag and oDiag, so that S' = U'^T . C . V' is diagonal. U' and V' are orthogonal
 matrices .

 Output:
   v     - (n x n) - matrix H . V' in the (n x n) part of v
   u     - (m x m) - matrix U'^T . Q^T
   sDiag - diagonal of the (m x n) S'

   return convergence flag:  0 -> no convergence
                             1 -> convergence

  Test code for the output:
    const Int_t nRow = v.GetNrows();
    const Int_t nCol = v.GetNcols();
    TMatrixD tmp = v; tmp.ResizeTo(nCol,nCol);
    TMatrixD Vprime  = Ht*tmp;
    TMatrixD Vprimet(TMatrixDBase::kTransposed,Vprime);
    TMatrixD Uprimet = u*Q;
    TMatrixD Uprime(TMatrixDBase::kTransposed,Uprimet);
    TMatrixD Sprime(nRow,nCol);
    TMatrixDDiag(Sprime) = sDiag;
    ok &= VerifyMatrixIdentity(Uprimet * C * Vprime,Sprime,kTRUE,1.0e-13);
    ok &= VerifyMatrixIdentity(Q*Uprime * Sprime * Vprimet * Ht,a,kTRUE,1.0e-13);

 Step 1 in the matrix diagonalization

 Step 2 in the matrix diagonalization

 Step 3 in the matrix diagonalization

 Perform a permutation transformation on the diagonal matrix S', so that
 matrix S'' = U''^T . S' . V''  has diagonal elements ordered such that they
 do not increase.

 Output:
   v     - (n x n) - matrix H . V' . V'' in the (n x n) part of v
   u     - (m x m) - matrix U''^T . U'^T . Q^T
   sDiag - diagonal of the (m x n) S''

 Reconstruct the original matrix using the decomposition parts

 Set matrix to be decomposed

 Solve Ax=b assuming the SVD form of A is stored . Solution returned in b.
 If A is of size (m x n), input vector b should be of size (m), however,
 the solution, returned in b, will be in the first (n) elements .

 For m > n , x  is the least-squares solution of min(A . x - b)

 Solve Ax=b assuming the SVD form of A is stored . Solution returned in the
 matrix column cb b.
 If A is of size (m x n), input vector b should be of size (m), however,
 the solution, returned in b, will be in the first (n) elements .

 For m > n , x  is the least-squares solution of min(A . x - b)

 Solve A^T x=b assuming the SVD form of A is stored . Solution returned in b.

 Solve A^T x=b assuming the SVD form of A is stored . Solution returned in b.

 Matrix condition number

 Matrix determinant det = d1*TMath::Power(2.,d2)

 For a matrix A(m,n), its inverse A_inv is defined as A * A_inv = A_inv * A = unit
 The user should always supply a matrix of size (m x m) !
 If m > n , only the (n x m) part of the returned (pseudo inverse) matrix
 should be used .

 For a matrix A(m,n), its inverse A_inv is defined as A * A_inv = A_inv * A = unit
 (n x m) Ainv is returned .

 Print class members

 Assignment operator