LAPACK  3.11.0
LAPACK: Linear Algebra PACKage
slals0.f
1 *> \brief \b SLALS0 applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download SLALS0 + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/slals0.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/slals0.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/slals0.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE SLALS0( ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX,
22 * PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM,
23 * POLES, DIFL, DIFR, Z, K, C, S, WORK, INFO )
24 *
25 * .. Scalar Arguments ..
26 * INTEGER GIVPTR, ICOMPQ, INFO, K, LDB, LDBX, LDGCOL,
27 * $ LDGNUM, NL, NR, NRHS, SQRE
28 * REAL C, S
29 * ..
30 * .. Array Arguments ..
31 * INTEGER GIVCOL( LDGCOL, * ), PERM( * )
32 * REAL B( LDB, * ), BX( LDBX, * ), DIFL( * ),
33 * $ DIFR( LDGNUM, * ), GIVNUM( LDGNUM, * ),
34 * $ POLES( LDGNUM, * ), WORK( * ), Z( * )
35 * ..
36 *
37 *
38 *> \par Purpose:
39 * =============
40 *>
41 *> \verbatim
42 *>
43 *> SLALS0 applies back the multiplying factors of either the left or the
44 *> right singular vector matrix of a diagonal matrix appended by a row
45 *> to the right hand side matrix B in solving the least squares problem
46 *> using the divide-and-conquer SVD approach.
47 *>
48 *> For the left singular vector matrix, three types of orthogonal
49 *> matrices are involved:
50 *>
51 *> (1L) Givens rotations: the number of such rotations is GIVPTR; the
52 *> pairs of columns/rows they were applied to are stored in GIVCOL;
53 *> and the C- and S-values of these rotations are stored in GIVNUM.
54 *>
55 *> (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
56 *> row, and for J=2:N, PERM(J)-th row of B is to be moved to the
57 *> J-th row.
58 *>
59 *> (3L) The left singular vector matrix of the remaining matrix.
60 *>
61 *> For the right singular vector matrix, four types of orthogonal
62 *> matrices are involved:
63 *>
64 *> (1R) The right singular vector matrix of the remaining matrix.
65 *>
66 *> (2R) If SQRE = 1, one extra Givens rotation to generate the right
67 *> null space.
68 *>
69 *> (3R) The inverse transformation of (2L).
70 *>
71 *> (4R) The inverse transformation of (1L).
72 *> \endverbatim
73 *
74 * Arguments:
75 * ==========
76 *
77 *> \param[in] ICOMPQ
78 *> \verbatim
79 *> ICOMPQ is INTEGER
80 *> Specifies whether singular vectors are to be computed in
81 *> factored form:
82 *> = 0: Left singular vector matrix.
83 *> = 1: Right singular vector matrix.
84 *> \endverbatim
85 *>
86 *> \param[in] NL
87 *> \verbatim
88 *> NL is INTEGER
89 *> The row dimension of the upper block. NL >= 1.
90 *> \endverbatim
91 *>
92 *> \param[in] NR
93 *> \verbatim
94 *> NR is INTEGER
95 *> The row dimension of the lower block. NR >= 1.
96 *> \endverbatim
97 *>
98 *> \param[in] SQRE
99 *> \verbatim
100 *> SQRE is INTEGER
101 *> = 0: the lower block is an NR-by-NR square matrix.
102 *> = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
103 *>
104 *> The bidiagonal matrix has row dimension N = NL + NR + 1,
105 *> and column dimension M = N + SQRE.
106 *> \endverbatim
107 *>
108 *> \param[in] NRHS
109 *> \verbatim
110 *> NRHS is INTEGER
111 *> The number of columns of B and BX. NRHS must be at least 1.
112 *> \endverbatim
113 *>
114 *> \param[in,out] B
115 *> \verbatim
116 *> B is REAL array, dimension ( LDB, NRHS )
117 *> On input, B contains the right hand sides of the least
118 *> squares problem in rows 1 through M. On output, B contains
119 *> the solution X in rows 1 through N.
120 *> \endverbatim
121 *>
122 *> \param[in] LDB
123 *> \verbatim
124 *> LDB is INTEGER
125 *> The leading dimension of B. LDB must be at least
126 *> max(1,MAX( M, N ) ).
127 *> \endverbatim
128 *>
129 *> \param[out] BX
130 *> \verbatim
131 *> BX is REAL array, dimension ( LDBX, NRHS )
132 *> \endverbatim
133 *>
134 *> \param[in] LDBX
135 *> \verbatim
136 *> LDBX is INTEGER
137 *> The leading dimension of BX.
138 *> \endverbatim
139 *>
140 *> \param[in] PERM
141 *> \verbatim
142 *> PERM is INTEGER array, dimension ( N )
143 *> The permutations (from deflation and sorting) applied
144 *> to the two blocks.
145 *> \endverbatim
146 *>
147 *> \param[in] GIVPTR
148 *> \verbatim
149 *> GIVPTR is INTEGER
150 *> The number of Givens rotations which took place in this
151 *> subproblem.
152 *> \endverbatim
153 *>
154 *> \param[in] GIVCOL
155 *> \verbatim
156 *> GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )
157 *> Each pair of numbers indicates a pair of rows/columns
158 *> involved in a Givens rotation.
159 *> \endverbatim
160 *>
161 *> \param[in] LDGCOL
162 *> \verbatim
163 *> LDGCOL is INTEGER
164 *> The leading dimension of GIVCOL, must be at least N.
165 *> \endverbatim
166 *>
167 *> \param[in] GIVNUM
168 *> \verbatim
169 *> GIVNUM is REAL array, dimension ( LDGNUM, 2 )
170 *> Each number indicates the C or S value used in the
171 *> corresponding Givens rotation.
172 *> \endverbatim
173 *>
174 *> \param[in] LDGNUM
175 *> \verbatim
176 *> LDGNUM is INTEGER
177 *> The leading dimension of arrays DIFR, POLES and
178 *> GIVNUM, must be at least K.
179 *> \endverbatim
180 *>
181 *> \param[in] POLES
182 *> \verbatim
183 *> POLES is REAL array, dimension ( LDGNUM, 2 )
184 *> On entry, POLES(1:K, 1) contains the new singular
185 *> values obtained from solving the secular equation, and
186 *> POLES(1:K, 2) is an array containing the poles in the secular
187 *> equation.
188 *> \endverbatim
189 *>
190 *> \param[in] DIFL
191 *> \verbatim
192 *> DIFL is REAL array, dimension ( K ).
193 *> On entry, DIFL(I) is the distance between I-th updated
194 *> (undeflated) singular value and the I-th (undeflated) old
195 *> singular value.
196 *> \endverbatim
197 *>
198 *> \param[in] DIFR
199 *> \verbatim
200 *> DIFR is REAL array, dimension ( LDGNUM, 2 ).
201 *> On entry, DIFR(I, 1) contains the distances between I-th
202 *> updated (undeflated) singular value and the I+1-th
203 *> (undeflated) old singular value. And DIFR(I, 2) is the
204 *> normalizing factor for the I-th right singular vector.
205 *> \endverbatim
206 *>
207 *> \param[in] Z
208 *> \verbatim
209 *> Z is REAL array, dimension ( K )
210 *> Contain the components of the deflation-adjusted updating row
211 *> vector.
212 *> \endverbatim
213 *>
214 *> \param[in] K
215 *> \verbatim
216 *> K is INTEGER
217 *> Contains the dimension of the non-deflated matrix,
218 *> This is the order of the related secular equation. 1 <= K <=N.
219 *> \endverbatim
220 *>
221 *> \param[in] C
222 *> \verbatim
223 *> C is REAL
224 *> C contains garbage if SQRE =0 and the C-value of a Givens
225 *> rotation related to the right null space if SQRE = 1.
226 *> \endverbatim
227 *>
228 *> \param[in] S
229 *> \verbatim
230 *> S is REAL
231 *> S contains garbage if SQRE =0 and the S-value of a Givens
232 *> rotation related to the right null space if SQRE = 1.
233 *> \endverbatim
234 *>
235 *> \param[out] WORK
236 *> \verbatim
237 *> WORK is REAL array, dimension ( K )
238 *> \endverbatim
239 *>
240 *> \param[out] INFO
241 *> \verbatim
242 *> INFO is INTEGER
243 *> = 0: successful exit.
244 *> < 0: if INFO = -i, the i-th argument had an illegal value.
245 *> \endverbatim
246 *
247 * Authors:
248 * ========
249 *
250 *> \author Univ. of Tennessee
251 *> \author Univ. of California Berkeley
252 *> \author Univ. of Colorado Denver
253 *> \author NAG Ltd.
254 *
255 *> \ingroup lals0
256 *
257 *> \par Contributors:
258 * ==================
259 *>
260 *> Ming Gu and Ren-Cang Li, Computer Science Division, University of
261 *> California at Berkeley, USA \n
262 *> Osni Marques, LBNL/NERSC, USA \n
263 *
264 * =====================================================================
265  SUBROUTINE slals0( ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX,
266  $ PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM,
267  $ POLES, DIFL, DIFR, Z, K, C, S, WORK, INFO )
268 *
269 * -- LAPACK computational routine --
270 * -- LAPACK is a software package provided by Univ. of Tennessee, --
271 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
272 *
273 * .. Scalar Arguments ..
274  INTEGER GIVPTR, ICOMPQ, INFO, K, LDB, LDBX, LDGCOL,
275  $ ldgnum, nl, nr, nrhs, sqre
276  REAL C, S
277 * ..
278 * .. Array Arguments ..
279  INTEGER GIVCOL( ldgcol, * ), PERM( * )
280  REAL B( ldb, * ), BX( ldbx, * ), DIFL( * ),
281  $ difr( ldgnum, * ), givnum( ldgnum, * ),
282  $ poles( ldgnum, * ), work( * ), z( * )
283 * ..
284 *
285 * =====================================================================
286 *
287 * .. Parameters ..
288  REAL ONE, ZERO, NEGONE
289  parameter( one = 1.0e0, zero = 0.0e0, negone = -1.0e0 )
290 * ..
291 * .. Local Scalars ..
292  INTEGER I, J, M, N, NLP1
293  REAL DIFLJ, DIFRJ, DJ, DSIGJ, DSIGJP, TEMP
294 * ..
295 * .. External Subroutines ..
296  EXTERNAL scopy, sgemv, slacpy, slascl, srot, sscal,
297  $ xerbla
298 * ..
299 * .. External Functions ..
300  REAL SLAMC3, SNRM2
301  EXTERNAL slamc3, snrm2
302 * ..
303 * .. Intrinsic Functions ..
304  INTRINSIC max
305 * ..
306 * .. Executable Statements ..
307 *
308 * Test the input parameters.
309 *
310  info = 0
311  n = nl + nr + 1
312 *
313  IF( ( icompq.LT.0 ) .OR. ( icompq.GT.1 ) ) THEN
314  info = -1
315  ELSE IF( nl.LT.1 ) THEN
316  info = -2
317  ELSE IF( nr.LT.1 ) THEN
318  info = -3
319  ELSE IF( ( sqre.LT.0 ) .OR. ( sqre.GT.1 ) ) THEN
320  info = -4
321  ELSE IF( nrhs.LT.1 ) THEN
322  info = -5
323  ELSE IF( ldb.LT.n ) THEN
324  info = -7
325  ELSE IF( ldbx.LT.n ) THEN
326  info = -9
327  ELSE IF( givptr.LT.0 ) THEN
328  info = -11
329  ELSE IF( ldgcol.LT.n ) THEN
330  info = -13
331  ELSE IF( ldgnum.LT.n ) THEN
332  info = -15
333  ELSE IF( k.LT.1 ) THEN
334  info = -20
335  END IF
336  IF( info.NE.0 ) THEN
337  CALL xerbla( 'SLALS0', -info )
338  RETURN
339  END IF
340 *
341  m = n + sqre
342  nlp1 = nl + 1
343 *
344  IF( icompq.EQ.0 ) THEN
345 *
346 * Apply back orthogonal transformations from the left.
347 *
348 * Step (1L): apply back the Givens rotations performed.
349 *
350  DO 10 i = 1, givptr
351  CALL srot( nrhs, b( givcol( i, 2 ), 1 ), ldb,
352  $ b( givcol( i, 1 ), 1 ), ldb, givnum( i, 2 ),
353  $ givnum( i, 1 ) )
354  10 CONTINUE
355 *
356 * Step (2L): permute rows of B.
357 *
358  CALL scopy( nrhs, b( nlp1, 1 ), ldb, bx( 1, 1 ), ldbx )
359  DO 20 i = 2, n
360  CALL scopy( nrhs, b( perm( i ), 1 ), ldb, bx( i, 1 ), ldbx )
361  20 CONTINUE
362 *
363 * Step (3L): apply the inverse of the left singular vector
364 * matrix to BX.
365 *
366  IF( k.EQ.1 ) THEN
367  CALL scopy( nrhs, bx, ldbx, b, ldb )
368  IF( z( 1 ).LT.zero ) THEN
369  CALL sscal( nrhs, negone, b, ldb )
370  END IF
371  ELSE
372  DO 50 j = 1, k
373  diflj = difl( j )
374  dj = poles( j, 1 )
375  dsigj = -poles( j, 2 )
376  IF( j.LT.k ) THEN
377  difrj = -difr( j, 1 )
378  dsigjp = -poles( j+1, 2 )
379  END IF
380  IF( ( z( j ).EQ.zero ) .OR. ( poles( j, 2 ).EQ.zero ) )
381  $ THEN
382  work( j ) = zero
383  ELSE
384  work( j ) = -poles( j, 2 )*z( j ) / diflj /
385  $ ( poles( j, 2 )+dj )
386  END IF
387  DO 30 i = 1, j - 1
388  IF( ( z( i ).EQ.zero ) .OR.
389  $ ( poles( i, 2 ).EQ.zero ) ) THEN
390  work( i ) = zero
391  ELSE
392  work( i ) = poles( i, 2 )*z( i ) /
393  $ ( slamc3( poles( i, 2 ), dsigj )-
394  $ diflj ) / ( poles( i, 2 )+dj )
395  END IF
396  30 CONTINUE
397  DO 40 i = j + 1, k
398  IF( ( z( i ).EQ.zero ) .OR.
399  $ ( poles( i, 2 ).EQ.zero ) ) THEN
400  work( i ) = zero
401  ELSE
402  work( i ) = poles( i, 2 )*z( i ) /
403  $ ( slamc3( poles( i, 2 ), dsigjp )+
404  $ difrj ) / ( poles( i, 2 )+dj )
405  END IF
406  40 CONTINUE
407  work( 1 ) = negone
408  temp = snrm2( k, work, 1 )
409  CALL sgemv( 'T', k, nrhs, one, bx, ldbx, work, 1, zero,
410  $ b( j, 1 ), ldb )
411  CALL slascl( 'G', 0, 0, temp, one, 1, nrhs, b( j, 1 ),
412  $ ldb, info )
413  50 CONTINUE
414  END IF
415 *
416 * Move the deflated rows of BX to B also.
417 *
418  IF( k.LT.max( m, n ) )
419  $ CALL slacpy( 'A', n-k, nrhs, bx( k+1, 1 ), ldbx,
420  $ b( k+1, 1 ), ldb )
421  ELSE
422 *
423 * Apply back the right orthogonal transformations.
424 *
425 * Step (1R): apply back the new right singular vector matrix
426 * to B.
427 *
428  IF( k.EQ.1 ) THEN
429  CALL scopy( nrhs, b, ldb, bx, ldbx )
430  ELSE
431  DO 80 j = 1, k
432  dsigj = poles( j, 2 )
433  IF( z( j ).EQ.zero ) THEN
434  work( j ) = zero
435  ELSE
436  work( j ) = -z( j ) / difl( j ) /
437  $ ( dsigj+poles( j, 1 ) ) / difr( j, 2 )
438  END IF
439  DO 60 i = 1, j - 1
440  IF( z( j ).EQ.zero ) THEN
441  work( i ) = zero
442  ELSE
443  work( i ) = z( j ) / ( slamc3( dsigj, -poles( i+1,
444  $ 2 ) )-difr( i, 1 ) ) /
445  $ ( dsigj+poles( i, 1 ) ) / difr( i, 2 )
446  END IF
447  60 CONTINUE
448  DO 70 i = j + 1, k
449  IF( z( j ).EQ.zero ) THEN
450  work( i ) = zero
451  ELSE
452  work( i ) = z( j ) / ( slamc3( dsigj, -poles( i,
453  $ 2 ) )-difl( i ) ) /
454  $ ( dsigj+poles( i, 1 ) ) / difr( i, 2 )
455  END IF
456  70 CONTINUE
457  CALL sgemv( 'T', k, nrhs, one, b, ldb, work, 1, zero,
458  $ bx( j, 1 ), ldbx )
459  80 CONTINUE
460  END IF
461 *
462 * Step (2R): if SQRE = 1, apply back the rotation that is
463 * related to the right null space of the subproblem.
464 *
465  IF( sqre.EQ.1 ) THEN
466  CALL scopy( nrhs, b( m, 1 ), ldb, bx( m, 1 ), ldbx )
467  CALL srot( nrhs, bx( 1, 1 ), ldbx, bx( m, 1 ), ldbx, c, s )
468  END IF
469  IF( k.LT.max( m, n ) )
470  $ CALL slacpy( 'A', n-k, nrhs, b( k+1, 1 ), ldb, bx( k+1, 1 ),
471  $ ldbx )
472 *
473 * Step (3R): permute rows of B.
474 *
475  CALL scopy( nrhs, bx( 1, 1 ), ldbx, b( nlp1, 1 ), ldb )
476  IF( sqre.EQ.1 ) THEN
477  CALL scopy( nrhs, bx( m, 1 ), ldbx, b( m, 1 ), ldb )
478  END IF
479  DO 90 i = 2, n
480  CALL scopy( nrhs, bx( i, 1 ), ldbx, b( perm( i ), 1 ), ldb )
481  90 CONTINUE
482 *
483 * Step (4R): apply back the Givens rotations performed.
484 *
485  DO 100 i = givptr, 1, -1
486  CALL srot( nrhs, b( givcol( i, 2 ), 1 ), ldb,
487  $ b( givcol( i, 1 ), 1 ), ldb, givnum( i, 2 ),
488  $ -givnum( i, 1 ) )
489  100 CONTINUE
490  END IF
491 *
492  RETURN
493 *
494 * End of SLALS0
495 *
496  END
xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
slascl
subroutine slascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
SLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: slascl.f:143
slals0
subroutine slals0(ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX, PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM, POLES, DIFL, DIFR, Z, K, C, S, WORK, INFO)
SLALS0 applies back multiplying factors in solving the least squares problem using divide and conquer...
Definition: slals0.f:268
scopy
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:82
sscal
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:79
srot
subroutine srot(N, SX, INCX, SY, INCY, C, S)
SROT
Definition: srot.f:92
sgemv
subroutine sgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
SGEMV
Definition: sgemv.f:156
slacpy
subroutine slacpy(UPLO, M, N, A, LDA, B, LDB)
SLACPY copies all or part of one two-dimensional array to another.
Definition: slacpy.f:103