zlals0.f

Go to the documentation of this file.

*> \brief \b ZLALS0 applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*> \htmlonly
*> Download ZLALS0 + dependencies 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlals0.f"> 
*> [TGZ]</a> 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlals0.f"> 
*> [ZIP]</a> 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlals0.f"> 
*> [TXT]</a>
*> \endhtmlonly 
*
*  Definition:
*  ===========
*
*       SUBROUTINE ZLALS0( ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX,
*                          PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM,
*                          POLES, DIFL, DIFR, Z, K, C, S, RWORK, INFO )
* 
*       .. Scalar Arguments ..
*       INTEGER            GIVPTR, ICOMPQ, INFO, K, LDB, LDBX, LDGCOL,
*      $                   LDGNUM, NL, NR, NRHS, SQRE
*       DOUBLE PRECISION   C, S
*       ..
*       .. Array Arguments ..
*       INTEGER            GIVCOL( LDGCOL, * ), PERM( * )
*       DOUBLE PRECISION   DIFL( * ), DIFR( LDGNUM, * ),
*      $                   GIVNUM( LDGNUM, * ), POLES( LDGNUM, * ),
*      $                   RWORK( * ), Z( * )
*       COMPLEX*16         B( LDB, * ), BX( LDBX, * )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> ZLALS0 applies back the multiplying factors of either the left or the
*> right singular vector matrix of a diagonal matrix appended by a row
*> to the right hand side matrix B in solving the least squares problem
*> using the divide-and-conquer SVD approach.
*>
*> For the left singular vector matrix, three types of orthogonal
*> matrices are involved:
*>
*> (1L) Givens rotations: the number of such rotations is GIVPTR; the
*>      pairs of columns/rows they were applied to are stored in GIVCOL;
*>      and the C- and S-values of these rotations are stored in GIVNUM.
*>
*> (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
*>      row, and for J=2:N, PERM(J)-th row of B is to be moved to the
*>      J-th row.
*>
*> (3L) The left singular vector matrix of the remaining matrix.
*>
*> For the right singular vector matrix, four types of orthogonal
*> matrices are involved:
*>
*> (1R) The right singular vector matrix of the remaining matrix.
*>
*> (2R) If SQRE = 1, one extra Givens rotation to generate the right
*>      null space.
*>
*> (3R) The inverse transformation of (2L).
*>
*> (4R) The inverse transformation of (1L).
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] ICOMPQ
*> \verbatim
*>          ICOMPQ is INTEGER
*>         Specifies whether singular vectors are to be computed in
*>         factored form:
*>         = 0: Left singular vector matrix.
*>         = 1: Right singular vector matrix.
*> \endverbatim
*>
*> \param[in] NL
*> \verbatim
*>          NL is INTEGER
*>         The row dimension of the upper block. NL >= 1.
*> \endverbatim
*>
*> \param[in] NR
*> \verbatim
*>          NR is INTEGER
*>         The row dimension of the lower block. NR >= 1.
*> \endverbatim
*>
*> \param[in] SQRE
*> \verbatim
*>          SQRE is INTEGER
*>         = 0: the lower block is an NR-by-NR square matrix.
*>         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
*>
*>         The bidiagonal matrix has row dimension N = NL + NR + 1,
*>         and column dimension M = N + SQRE.
*> \endverbatim
*>
*> \param[in] NRHS
*> \verbatim
*>          NRHS is INTEGER
*>         The number of columns of B and BX. NRHS must be at least 1.
*> \endverbatim
*>
*> \param[in,out] B
*> \verbatim
*>          B is COMPLEX*16 array, dimension ( LDB, NRHS )
*>         On input, B contains the right hand sides of the least
*>         squares problem in rows 1 through M. On output, B contains
*>         the solution X in rows 1 through N.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*>          LDB is INTEGER
*>         The leading dimension of B. LDB must be at least
*>         max(1,MAX( M, N ) ).
*> \endverbatim
*>
*> \param[out] BX
*> \verbatim
*>          BX is COMPLEX*16 array, dimension ( LDBX, NRHS )
*> \endverbatim
*>
*> \param[in] LDBX
*> \verbatim
*>          LDBX is INTEGER
*>         The leading dimension of BX.
*> \endverbatim
*>
*> \param[in] PERM
*> \verbatim
*>          PERM is INTEGER array, dimension ( N )
*>         The permutations (from deflation and sorting) applied
*>         to the two blocks.
*> \endverbatim
*>
*> \param[in] GIVPTR
*> \verbatim
*>          GIVPTR is INTEGER
*>         The number of Givens rotations which took place in this
*>         subproblem.
*> \endverbatim
*>
*> \param[in] GIVCOL
*> \verbatim
*>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )
*>         Each pair of numbers indicates a pair of rows/columns
*>         involved in a Givens rotation.
*> \endverbatim
*>
*> \param[in] LDGCOL
*> \verbatim
*>          LDGCOL is INTEGER
*>         The leading dimension of GIVCOL, must be at least N.
*> \endverbatim
*>
*> \param[in] GIVNUM
*> \verbatim
*>          GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )
*>         Each number indicates the C or S value used in the
*>         corresponding Givens rotation.
*> \endverbatim
*>
*> \param[in] LDGNUM
*> \verbatim
*>          LDGNUM is INTEGER
*>         The leading dimension of arrays DIFR, POLES and
*>         GIVNUM, must be at least K.
*> \endverbatim
*>
*> \param[in] POLES
*> \verbatim
*>          POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )
*>         On entry, POLES(1:K, 1) contains the new singular
*>         values obtained from solving the secular equation, and
*>         POLES(1:K, 2) is an array containing the poles in the secular
*>         equation.
*> \endverbatim
*>
*> \param[in] DIFL
*> \verbatim
*>          DIFL is DOUBLE PRECISION array, dimension ( K ).
*>         On entry, DIFL(I) is the distance between I-th updated
*>         (undeflated) singular value and the I-th (undeflated) old
*>         singular value.
*> \endverbatim
*>
*> \param[in] DIFR
*> \verbatim
*>          DIFR is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ).
*>         On entry, DIFR(I, 1) contains the distances between I-th
*>         updated (undeflated) singular value and the I+1-th
*>         (undeflated) old singular value. And DIFR(I, 2) is the
*>         normalizing factor for the I-th right singular vector.
*> \endverbatim
*>
*> \param[in] Z
*> \verbatim
*>          Z is DOUBLE PRECISION array, dimension ( K )
*>         Contain the components of the deflation-adjusted updating row
*>         vector.
*> \endverbatim
*>
*> \param[in] K
*> \verbatim
*>          K is INTEGER
*>         Contains the dimension of the non-deflated matrix,
*>         This is the order of the related secular equation. 1 <= K <=N.
*> \endverbatim
*>
*> \param[in] C
*> \verbatim
*>          C is DOUBLE PRECISION
*>         C contains garbage if SQRE =0 and the C-value of a Givens
*>         rotation related to the right null space if SQRE = 1.
*> \endverbatim
*>
*> \param[in] S
*> \verbatim
*>          S is DOUBLE PRECISION
*>         S contains garbage if SQRE =0 and the S-value of a Givens
*>         rotation related to the right null space if SQRE = 1.
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is DOUBLE PRECISION array, dimension
*>         ( K*(1+NRHS) + 2*NRHS )
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*>          INFO is INTEGER
*>          = 0:  successful exit.
*>          < 0:  if INFO = -i, the i-th argument had an illegal value.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee 
*> \author Univ. of California Berkeley 
*> \author Univ. of Colorado Denver 
*> \author NAG Ltd. 
*
*> \date November 2015
*
*> \ingroup complex16OTHERcomputational
*
*> \par Contributors:
*  ==================
*>
*>     Ming Gu and Ren-Cang Li, Computer Science Division, University of
*>       California at Berkeley, USA \n
*>     Osni Marques, LBNL/NERSC, USA \n
*
*  =====================================================================
      SUBROUTINE zlals0( ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX,
     $                   perm, givptr, givcol, ldgcol, givnum, ldgnum,
     $                   poles, difl, difr, z, k, c, s, rwork, info )
*
*  -- LAPACK computational routine (version 3.6.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2015
*
*     .. Scalar Arguments ..
      INTEGER            GIVPTR, ICOMPQ, INFO, K, LDB, LDBX, LDGCOL,
     $                   ldgnum, nl, nr, nrhs, sqre
      DOUBLE PRECISION   C, S
*     ..
*     .. Array Arguments ..
      INTEGER            GIVCOL( ldgcol, * ), PERM( * )
      DOUBLE PRECISION   DIFL( * ), DIFR( ldgnum, * ),
     $                   givnum( ldgnum, * ), poles( ldgnum, * ),
     $                   rwork( * ), z( * )
      COMPLEX*16         B( ldb, * ), BX( ldbx, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE, ZERO, NEGONE
      parameter                ( one = 1.0d0, zero = 0.0d0, negone = -1.0d0 )
*     ..
*     .. Local Scalars ..
      INTEGER            I, J, JCOL, JROW, M, N, NLP1
      DOUBLE PRECISION   DIFLJ, DIFRJ, DJ, DSIGJ, DSIGJP, TEMP
*     ..
*     .. External Subroutines ..
      EXTERNAL           dgemv, xerbla, zcopy, zdrot, zdscal, zlacpy,
     $                   zlascl
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMC3, DNRM2
      EXTERNAL           dlamc3, dnrm2
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble, dcmplx, dimag, max
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      n = nl + nr + 1
*
      IF( ( icompq.LT.0 ) .OR. ( icompq.GT.1 ) ) THEN
         info = -1
      ELSE IF( nl.LT.1 ) THEN
         info = -2
      ELSE IF( nr.LT.1 ) THEN
         info = -3
      ELSE IF( ( sqre.LT.0 ) .OR. ( sqre.GT.1 ) ) THEN
         info = -4
      ELSE IF( nrhs.LT.1 ) THEN
         info = -5
      ELSE IF( ldb.LT.n ) THEN
         info = -7
      ELSE IF( ldbx.LT.n ) THEN
         info = -9
      ELSE IF( givptr.LT.0 ) THEN
         info = -11
      ELSE IF( ldgcol.LT.n ) THEN
         info = -13
      ELSE IF( ldgnum.LT.n ) THEN
         info = -15
      ELSE IF( k.LT.1 ) THEN
         info = -20
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZLALS0', -info )
         RETURN
      END IF
*
      m = n + sqre
      nlp1 = nl + 1
*
      IF( icompq.EQ.0 ) THEN
*
*        Apply back orthogonal transformations from the left.
*
*        Step (1L): apply back the Givens rotations performed.
*
         DO 10 i = 1, givptr
            CALL zdrot( nrhs, b( givcol( i, 2 ), 1 ), ldb,
     $                  b( givcol( i, 1 ), 1 ), ldb, givnum( i, 2 ),
     $                  givnum( i, 1 ) )
   10    CONTINUE
*
*        Step (2L): permute rows of B.
*
         CALL zcopy( nrhs, b( nlp1, 1 ), ldb, bx( 1, 1 ), ldbx )
         DO 20 i = 2, n
            CALL zcopy( nrhs, b( perm( i ), 1 ), ldb, bx( i, 1 ), ldbx )
   20    CONTINUE
*
*        Step (3L): apply the inverse of the left singular vector
*        matrix to BX.
*
         IF( k.EQ.1 ) THEN
            CALL zcopy( nrhs, bx, ldbx, b, ldb )
            IF( z( 1 ).LT.zero ) THEN
               CALL zdscal( nrhs, negone, b, ldb )
            END IF
         ELSE
            DO 100 j = 1, k
               diflj = difl( j )
               dj = poles( j, 1 )
               dsigj = -poles( j, 2 )
               IF( j.LT.k ) THEN
                  difrj = -difr( j, 1 )
                  dsigjp = -poles( j+1, 2 )
               END IF
               IF( ( z( j ).EQ.zero ) .OR. ( poles( j, 2 ).EQ.zero ) )
     $              THEN
                  rwork( j ) = zero
               ELSE
                  rwork( j ) = -poles( j, 2 )*z( j ) / diflj /
     $                         ( poles( j, 2 )+dj )
               END IF
               DO 30 i = 1, j - 1
                  IF( ( z( i ).EQ.zero ) .OR.
     $                ( poles( i, 2 ).EQ.zero ) ) THEN
                     rwork( i ) = zero
                  ELSE
                     rwork( i ) = poles( i, 2 )*z( i ) /
     $                            ( dlamc3( poles( i, 2 ), dsigj )-
     $                            diflj ) / ( poles( i, 2 )+dj )
                  END IF
   30          CONTINUE
               DO 40 i = j + 1, k
                  IF( ( z( i ).EQ.zero ) .OR.
     $                ( poles( i, 2 ).EQ.zero ) ) THEN
                     rwork( i ) = zero
                  ELSE
                     rwork( i ) = poles( i, 2 )*z( i ) /
     $                            ( dlamc3( poles( i, 2 ), dsigjp )+
     $                            difrj ) / ( poles( i, 2 )+dj )
                  END IF
   40          CONTINUE
               rwork( 1 ) = negone
               temp = dnrm2( k, rwork, 1 )
*
*              Since B and BX are complex, the following call to DGEMV
*              is performed in two steps (real and imaginary parts).
*
*              CALL DGEMV( 'T', K, NRHS, ONE, BX, LDBX, WORK, 1, ZERO,
*    $                     B( J, 1 ), LDB )
*
               i = k + nrhs*2
               DO 60 jcol = 1, nrhs
                  DO 50 jrow = 1, k
                     i = i + 1
                     rwork( i ) = dble( bx( jrow, jcol ) )
   50             CONTINUE
   60          CONTINUE
               CALL dgemv( 'T', k, nrhs, one, rwork( 1+k+nrhs*2 ), k,
     $                     rwork( 1 ), 1, zero, rwork( 1+k ), 1 )
               i = k + nrhs*2
               DO 80 jcol = 1, nrhs
                  DO 70 jrow = 1, k
                     i = i + 1
                     rwork( i ) = dimag( bx( jrow, jcol ) )
   70             CONTINUE
   80          CONTINUE
               CALL dgemv( 'T', k, nrhs, one, rwork( 1+k+nrhs*2 ), k,
     $                     rwork( 1 ), 1, zero, rwork( 1+k+nrhs ), 1 )
               DO 90 jcol = 1, nrhs
                  b( j, jcol ) = dcmplx( rwork( jcol+k ),
     $                           rwork( jcol+k+nrhs ) )
   90          CONTINUE
               CALL zlascl( 'G', 0, 0, temp, one, 1, nrhs, b( j, 1 ),
     $                      ldb, info )
  100       CONTINUE
         END IF
*
*        Move the deflated rows of BX to B also.
*
         IF( k.LT.max( m, n ) )
     $      CALL zlacpy( 'A', n-k, nrhs, bx( k+1, 1 ), ldbx,
     $                   b( k+1, 1 ), ldb )
      ELSE
*
*        Apply back the right orthogonal transformations.
*
*        Step (1R): apply back the new right singular vector matrix
*        to B.
*
         IF( k.EQ.1 ) THEN
            CALL zcopy( nrhs, b, ldb, bx, ldbx )
         ELSE
            DO 180 j = 1, k
               dsigj = poles( j, 2 )
               IF( z( j ).EQ.zero ) THEN
                  rwork( j ) = zero
               ELSE
                  rwork( j ) = -z( j ) / difl( j ) /
     $                         ( dsigj+poles( j, 1 ) ) / difr( j, 2 )
               END IF
               DO 110 i = 1, j - 1
                  IF( z( j ).EQ.zero ) THEN
                     rwork( i ) = zero
                  ELSE
                     rwork( i ) = z( j ) / ( dlamc3( dsigj, -poles( i+1,
     $                            2 ) )-difr( i, 1 ) ) /
     $                            ( dsigj+poles( i, 1 ) ) / difr( i, 2 )
                  END IF
  110          CONTINUE
               DO 120 i = j + 1, k
                  IF( z( j ).EQ.zero ) THEN
                     rwork( i ) = zero
                  ELSE
                     rwork( i ) = z( j ) / ( dlamc3( dsigj, -poles( i,
     $                            2 ) )-difl( i ) ) /
     $                            ( dsigj+poles( i, 1 ) ) / difr( i, 2 )
                  END IF
  120          CONTINUE
*
*              Since B and BX are complex, the following call to DGEMV
*              is performed in two steps (real and imaginary parts).
*
*              CALL DGEMV( 'T', K, NRHS, ONE, B, LDB, WORK, 1, ZERO,
*    $                     BX( J, 1 ), LDBX )
*
               i = k + nrhs*2
               DO 140 jcol = 1, nrhs
                  DO 130 jrow = 1, k
                     i = i + 1
                     rwork( i ) = dble( b( jrow, jcol ) )
  130             CONTINUE
  140          CONTINUE
               CALL dgemv( 'T', k, nrhs, one, rwork( 1+k+nrhs*2 ), k,
     $                     rwork( 1 ), 1, zero, rwork( 1+k ), 1 )
               i = k + nrhs*2
               DO 160 jcol = 1, nrhs
                  DO 150 jrow = 1, k
                     i = i + 1
                     rwork( i ) = dimag( b( jrow, jcol ) )
  150             CONTINUE
  160          CONTINUE
               CALL dgemv( 'T', k, nrhs, one, rwork( 1+k+nrhs*2 ), k,
     $                     rwork( 1 ), 1, zero, rwork( 1+k+nrhs ), 1 )
               DO 170 jcol = 1, nrhs
                  bx( j, jcol ) = dcmplx( rwork( jcol+k ),
     $                            rwork( jcol+k+nrhs ) )
  170          CONTINUE
  180       CONTINUE
         END IF
*
*        Step (2R): if SQRE = 1, apply back the rotation that is
*        related to the right null space of the subproblem.
*
         IF( sqre.EQ.1 ) THEN
            CALL zcopy( nrhs, b( m, 1 ), ldb, bx( m, 1 ), ldbx )
            CALL zdrot( nrhs, bx( 1, 1 ), ldbx, bx( m, 1 ), ldbx, c, s )
         END IF
         IF( k.LT.max( m, n ) )
     $      CALL zlacpy( 'A', n-k, nrhs, b( k+1, 1 ), ldb, bx( k+1, 1 ),
     $                   ldbx )
*
*        Step (3R): permute rows of B.
*
         CALL zcopy( nrhs, bx( 1, 1 ), ldbx, b( nlp1, 1 ), ldb )
         IF( sqre.EQ.1 ) THEN
            CALL zcopy( nrhs, bx( m, 1 ), ldbx, b( m, 1 ), ldb )
         END IF
         DO 190 i = 2, n
            CALL zcopy( nrhs, bx( i, 1 ), ldbx, b( perm( i ), 1 ), ldb )
  190    CONTINUE
*
*        Step (4R): apply back the Givens rotations performed.
*
         DO 200 i = givptr, 1, -1
            CALL zdrot( nrhs, b( givcol( i, 2 ), 1 ), ldb,
     $                  b( givcol( i, 1 ), 1 ), ldb, givnum( i, 2 ),
     $                  -givnum( i, 1 ) )
  200    CONTINUE
      END IF
*
      RETURN
*
*     End of ZLALS0
*
      END