LAPACK: SRC/slals0.f Source File

Go to the documentation of this file.
00001       SUBROUTINE SLALS0( ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX,
00002      $                   PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM,
00003      $                   POLES, DIFL, DIFR, Z, K, C, S, WORK, INFO )
00004 *
00005 *  -- LAPACK routine (version 3.2) --
00006 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00007 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00008 *     November 2006
00009 *
00010 *     .. Scalar Arguments ..
00011       INTEGER            GIVPTR, ICOMPQ, INFO, K, LDB, LDBX, LDGCOL,
00012      $                   LDGNUM, NL, NR, NRHS, SQRE
00013       REAL               C, S
00014 *     ..
00015 *     .. Array Arguments ..
00016       INTEGER            GIVCOL( LDGCOL, * ), PERM( * )
00017       REAL               B( LDB, * ), BX( LDBX, * ), DIFL( * ),
00018      $                   DIFR( LDGNUM, * ), GIVNUM( LDGNUM, * ),
00019      $                   POLES( LDGNUM, * ), WORK( * ), Z( * )
00020 *     ..
00021 *
00022 *  Purpose
00023 *  =======
00024 *
00025 *  SLALS0 applies back the multiplying factors of either the left or the
00026 *  right singular vector matrix of a diagonal matrix appended by a row
00027 *  to the right hand side matrix B in solving the least squares problem
00028 *  using the divide-and-conquer SVD approach.
00029 *
00030 *  For the left singular vector matrix, three types of orthogonal
00031 *  matrices are involved:
00032 *
00033 *  (1L) Givens rotations: the number of such rotations is GIVPTR; the
00034 *       pairs of columns/rows they were applied to are stored in GIVCOL;
00035 *       and the C- and S-values of these rotations are stored in GIVNUM.
00036 *
00037 *  (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
00038 *       row, and for J=2:N, PERM(J)-th row of B is to be moved to the
00039 *       J-th row.
00040 *
00041 *  (3L) The left singular vector matrix of the remaining matrix.
00042 *
00043 *  For the right singular vector matrix, four types of orthogonal
00044 *  matrices are involved:
00045 *
00046 *  (1R) The right singular vector matrix of the remaining matrix.
00047 *
00048 *  (2R) If SQRE = 1, one extra Givens rotation to generate the right
00049 *       null space.
00050 *
00051 *  (3R) The inverse transformation of (2L).
00052 *
00053 *  (4R) The inverse transformation of (1L).
00054 *
00055 *  Arguments
00056 *  =========
00057 *
00058 *  ICOMPQ (input) INTEGER
00059 *         Specifies whether singular vectors are to be computed in
00060 *         factored form:
00061 *         = 0: Left singular vector matrix.
00062 *         = 1: Right singular vector matrix.
00063 *
00064 *  NL     (input) INTEGER
00065 *         The row dimension of the upper block. NL >= 1.
00066 *
00067 *  NR     (input) INTEGER
00068 *         The row dimension of the lower block. NR >= 1.
00069 *
00070 *  SQRE   (input) INTEGER
00071 *         = 0: the lower block is an NR-by-NR square matrix.
00072 *         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
00073 *
00074 *         The bidiagonal matrix has row dimension N = NL + NR + 1,
00075 *         and column dimension M = N + SQRE.
00076 *
00077 *  NRHS   (input) INTEGER
00078 *         The number of columns of B and BX. NRHS must be at least 1.
00079 *
00080 *  B      (input/output) REAL array, dimension ( LDB, NRHS )
00081 *         On input, B contains the right hand sides of the least
00082 *         squares problem in rows 1 through M. On output, B contains
00083 *         the solution X in rows 1 through N.
00084 *
00085 *  LDB    (input) INTEGER
00086 *         The leading dimension of B. LDB must be at least
00087 *         max(1,MAX( M, N ) ).
00088 *
00089 *  BX     (workspace) REAL array, dimension ( LDBX, NRHS )
00090 *
00091 *  LDBX   (input) INTEGER
00092 *         The leading dimension of BX.
00093 *
00094 *  PERM   (input) INTEGER array, dimension ( N )
00095 *         The permutations (from deflation and sorting) applied
00096 *         to the two blocks.
00097 *
00098 *  GIVPTR (input) INTEGER
00099 *         The number of Givens rotations which took place in this
00100 *         subproblem.
00101 *
00102 *  GIVCOL (input) INTEGER array, dimension ( LDGCOL, 2 )
00103 *         Each pair of numbers indicates a pair of rows/columns
00104 *         involved in a Givens rotation.
00105 *
00106 *  LDGCOL (input) INTEGER
00107 *         The leading dimension of GIVCOL, must be at least N.
00108 *
00109 *  GIVNUM (input) REAL array, dimension ( LDGNUM, 2 )
00110 *         Each number indicates the C or S value used in the
00111 *         corresponding Givens rotation.
00112 *
00113 *  LDGNUM (input) INTEGER
00114 *         The leading dimension of arrays DIFR, POLES and
00115 *         GIVNUM, must be at least K.
00116 *
00117 *  POLES  (input) REAL array, dimension ( LDGNUM, 2 )
00118 *         On entry, POLES(1:K, 1) contains the new singular
00119 *         values obtained from solving the secular equation, and
00120 *         POLES(1:K, 2) is an array containing the poles in the secular
00121 *         equation.
00122 *
00123 *  DIFL   (input) REAL array, dimension ( K ).
00124 *         On entry, DIFL(I) is the distance between I-th updated
00125 *         (undeflated) singular value and the I-th (undeflated) old
00126 *         singular value.
00127 *
00128 *  DIFR   (input) REAL array, dimension ( LDGNUM, 2 ).
00129 *         On entry, DIFR(I, 1) contains the distances between I-th
00130 *         updated (undeflated) singular value and the I+1-th
00131 *         (undeflated) old singular value. And DIFR(I, 2) is the
00132 *         normalizing factor for the I-th right singular vector.
00133 *
00134 *  Z      (input) REAL array, dimension ( K )
00135 *         Contain the components of the deflation-adjusted updating row
00136 *         vector.
00137 *
00138 *  K      (input) INTEGER
00139 *         Contains the dimension of the non-deflated matrix,
00140 *         This is the order of the related secular equation. 1 <= K <=N.
00141 *
00142 *  C      (input) REAL
00143 *         C contains garbage if SQRE =0 and the C-value of a Givens
00144 *         rotation related to the right null space if SQRE = 1.
00145 *
00146 *  S      (input) REAL
00147 *         S contains garbage if SQRE =0 and the S-value of a Givens
00148 *         rotation related to the right null space if SQRE = 1.
00149 *
00150 *  WORK   (workspace) REAL array, dimension ( K )
00151 *
00152 *  INFO   (output) INTEGER
00153 *          = 0:  successful exit.
00154 *          < 0:  if INFO = -i, the i-th argument had an illegal value.
00155 *
00156 *  Further Details
00157 *  ===============
00158 *
00159 *  Based on contributions by
00160 *     Ming Gu and Ren-Cang Li, Computer Science Division, University of
00161 *       California at Berkeley, USA
00162 *     Osni Marques, LBNL/NERSC, USA
00163 *
00164 *  =====================================================================
00165 *
00166 *     .. Parameters ..
00167       REAL               ONE, ZERO, NEGONE
00168       PARAMETER          ( ONE = 1.0E0, ZERO = 0.0E0, NEGONE = -1.0E0 )
00169 *     ..
00170 *     .. Local Scalars ..
00171       INTEGER            I, J, M, N, NLP1
00172       REAL               DIFLJ, DIFRJ, DJ, DSIGJ, DSIGJP, TEMP
00173 *     ..
00174 *     .. External Subroutines ..
00175       EXTERNAL           SCOPY, SGEMV, SLACPY, SLASCL, SROT, SSCAL,
00176      $                   XERBLA
00177 *     ..
00178 *     .. External Functions ..
00179       REAL               SLAMC3, SNRM2
00180       EXTERNAL           SLAMC3, SNRM2
00181 *     ..
00182 *     .. Intrinsic Functions ..
00183       INTRINSIC          MAX
00184 *     ..
00185 *     .. Executable Statements ..
00186 *
00187 *     Test the input parameters.
00188 *
00189       INFO = 0
00190 *
00191       IF( ( ICOMPQ.LT.0 ) .OR. ( ICOMPQ.GT.1 ) ) THEN
00192          INFO = -1
00193       ELSE IF( NL.LT.1 ) THEN
00194          INFO = -2
00195       ELSE IF( NR.LT.1 ) THEN
00196          INFO = -3
00197       ELSE IF( ( SQRE.LT.0 ) .OR. ( SQRE.GT.1 ) ) THEN
00198          INFO = -4
00199       END IF
00200 *
00201       N = NL + NR + 1
00202 *
00203       IF( NRHS.LT.1 ) THEN
00204          INFO = -5
00205       ELSE IF( LDB.LT.N ) THEN
00206          INFO = -7
00207       ELSE IF( LDBX.LT.N ) THEN
00208          INFO = -9
00209       ELSE IF( GIVPTR.LT.0 ) THEN
00210          INFO = -11
00211       ELSE IF( LDGCOL.LT.N ) THEN
00212          INFO = -13
00213       ELSE IF( LDGNUM.LT.N ) THEN
00214          INFO = -15
00215       ELSE IF( K.LT.1 ) THEN
00216          INFO = -20
00217       END IF
00218       IF( INFO.NE.0 ) THEN
00219          CALL XERBLA( 'SLALS0', -INFO )
00220          RETURN
00221       END IF
00222 *
00223       M = N + SQRE
00224       NLP1 = NL + 1
00225 *
00226       IF( ICOMPQ.EQ.0 ) THEN
00227 *
00228 *        Apply back orthogonal transformations from the left.
00229 *
00230 *        Step (1L): apply back the Givens rotations performed.
00231 *
00232          DO 10 I = 1, GIVPTR
00233             CALL SROT( NRHS, B( GIVCOL( I, 2 ), 1 ), LDB,
00234      $                 B( GIVCOL( I, 1 ), 1 ), LDB, GIVNUM( I, 2 ),
00235      $                 GIVNUM( I, 1 ) )
00236    10    CONTINUE
00237 *
00238 *        Step (2L): permute rows of B.
00239 *
00240          CALL SCOPY( NRHS, B( NLP1, 1 ), LDB, BX( 1, 1 ), LDBX )
00241          DO 20 I = 2, N
00242             CALL SCOPY( NRHS, B( PERM( I ), 1 ), LDB, BX( I, 1 ), LDBX )
00243    20    CONTINUE
00244 *
00245 *        Step (3L): apply the inverse of the left singular vector
00246 *        matrix to BX.
00247 *
00248          IF( K.EQ.1 ) THEN
00249             CALL SCOPY( NRHS, BX, LDBX, B, LDB )
00250             IF( Z( 1 ).LT.ZERO ) THEN
00251                CALL SSCAL( NRHS, NEGONE, B, LDB )
00252             END IF
00253          ELSE
00254             DO 50 J = 1, K
00255                DIFLJ = DIFL( J )
00256                DJ = POLES( J, 1 )
00257                DSIGJ = -POLES( J, 2 )
00258                IF( J.LT.K ) THEN
00259                   DIFRJ = -DIFR( J, 1 )
00260                   DSIGJP = -POLES( J+1, 2 )
00261                END IF
00262                IF( ( Z( J ).EQ.ZERO ) .OR. ( POLES( J, 2 ).EQ.ZERO ) )
00263      $              THEN
00264                   WORK( J ) = ZERO
00265                ELSE
00266                   WORK( J ) = -POLES( J, 2 )*Z( J ) / DIFLJ /
00267      $                        ( POLES( J, 2 )+DJ )
00268                END IF
00269                DO 30 I = 1, J - 1
00270                   IF( ( Z( I ).EQ.ZERO ) .OR.
00271      $                ( POLES( I, 2 ).EQ.ZERO ) ) THEN
00272                      WORK( I ) = ZERO
00273                   ELSE
00274                      WORK( I ) = POLES( I, 2 )*Z( I ) /
00275      $                           ( SLAMC3( POLES( I, 2 ), DSIGJ )-
00276      $                           DIFLJ ) / ( POLES( I, 2 )+DJ )
00277                   END IF
00278    30          CONTINUE
00279                DO 40 I = J + 1, K
00280                   IF( ( Z( I ).EQ.ZERO ) .OR.
00281      $                ( POLES( I, 2 ).EQ.ZERO ) ) THEN
00282                      WORK( I ) = ZERO
00283                   ELSE
00284                      WORK( I ) = POLES( I, 2 )*Z( I ) /
00285      $                           ( SLAMC3( POLES( I, 2 ), DSIGJP )+
00286      $                           DIFRJ ) / ( POLES( I, 2 )+DJ )
00287                   END IF
00288    40          CONTINUE
00289                WORK( 1 ) = NEGONE
00290                TEMP = SNRM2( K, WORK, 1 )
00291                CALL SGEMV( 'T', K, NRHS, ONE, BX, LDBX, WORK, 1, ZERO,
00292      $                     B( J, 1 ), LDB )
00293                CALL SLASCL( 'G', 0, 0, TEMP, ONE, 1, NRHS, B( J, 1 ),
00294      $                      LDB, INFO )
00295    50       CONTINUE
00296          END IF
00297 *
00298 *        Move the deflated rows of BX to B also.
00299 *
00300          IF( K.LT.MAX( M, N ) )
00301      $      CALL SLACPY( 'A', N-K, NRHS, BX( K+1, 1 ), LDBX,
00302      $                   B( K+1, 1 ), LDB )
00303       ELSE
00304 *
00305 *        Apply back the right orthogonal transformations.
00306 *
00307 *        Step (1R): apply back the new right singular vector matrix
00308 *        to B.
00309 *
00310          IF( K.EQ.1 ) THEN
00311             CALL SCOPY( NRHS, B, LDB, BX, LDBX )
00312          ELSE
00313             DO 80 J = 1, K
00314                DSIGJ = POLES( J, 2 )
00315                IF( Z( J ).EQ.ZERO ) THEN
00316                   WORK( J ) = ZERO
00317                ELSE
00318                   WORK( J ) = -Z( J ) / DIFL( J ) /
00319      $                        ( DSIGJ+POLES( J, 1 ) ) / DIFR( J, 2 )
00320                END IF
00321                DO 60 I = 1, J - 1
00322                   IF( Z( J ).EQ.ZERO ) THEN
00323                      WORK( I ) = ZERO
00324                   ELSE
00325                      WORK( I ) = Z( J ) / ( SLAMC3( DSIGJ, -POLES( I+1,
00326      $                           2 ) )-DIFR( I, 1 ) ) /
00327      $                           ( DSIGJ+POLES( I, 1 ) ) / DIFR( I, 2 )
00328                   END IF
00329    60          CONTINUE
00330                DO 70 I = J + 1, K
00331                   IF( Z( J ).EQ.ZERO ) THEN
00332                      WORK( I ) = ZERO
00333                   ELSE
00334                      WORK( I ) = Z( J ) / ( SLAMC3( DSIGJ, -POLES( I,
00335      $                           2 ) )-DIFL( I ) ) /
00336      $                           ( DSIGJ+POLES( I, 1 ) ) / DIFR( I, 2 )
00337                   END IF
00338    70          CONTINUE
00339                CALL SGEMV( 'T', K, NRHS, ONE, B, LDB, WORK, 1, ZERO,
00340      $                     BX( J, 1 ), LDBX )
00341    80       CONTINUE
00342          END IF
00343 *
00344 *        Step (2R): if SQRE = 1, apply back the rotation that is
00345 *        related to the right null space of the subproblem.
00346 *
00347          IF( SQRE.EQ.1 ) THEN
00348             CALL SCOPY( NRHS, B( M, 1 ), LDB, BX( M, 1 ), LDBX )
00349             CALL SROT( NRHS, BX( 1, 1 ), LDBX, BX( M, 1 ), LDBX, C, S )
00350          END IF
00351          IF( K.LT.MAX( M, N ) )
00352      $      CALL SLACPY( 'A', N-K, NRHS, B( K+1, 1 ), LDB, BX( K+1, 1 ),
00353      $                   LDBX )
00354 *
00355 *        Step (3R): permute rows of B.
00356 *
00357          CALL SCOPY( NRHS, BX( 1, 1 ), LDBX, B( NLP1, 1 ), LDB )
00358          IF( SQRE.EQ.1 ) THEN
00359             CALL SCOPY( NRHS, BX( M, 1 ), LDBX, B( M, 1 ), LDB )
00360          END IF
00361          DO 90 I = 2, N
00362             CALL SCOPY( NRHS, BX( I, 1 ), LDBX, B( PERM( I ), 1 ), LDB )
00363    90    CONTINUE
00364 *
00365 *        Step (4R): apply back the Givens rotations performed.
00366 *
00367          DO 100 I = GIVPTR, 1, -1
00368             CALL SROT( NRHS, B( GIVCOL( I, 2 ), 1 ), LDB,
00369      $                 B( GIVCOL( I, 1 ), 1 ), LDB, GIVNUM( I, 2 ),
00370      $                 -GIVNUM( I, 1 ) )
00371   100    CONTINUE
00372       END IF
00373 *
00374       RETURN
00375 *
00376 *     End of SLALS0
00377 *
00378       END