LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
 All Files Functions Groups
cbbcsd.f
Go to the documentation of this file.
1 *> \brief \b CBBCSD
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download CBBCSD + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cbbcsd.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cbbcsd.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cbbcsd.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE CBBCSD( JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, M, P, Q,
22 * THETA, PHI, U1, LDU1, U2, LDU2, V1T, LDV1T,
23 * V2T, LDV2T, B11D, B11E, B12D, B12E, B21D, B21E,
24 * B22D, B22E, RWORK, LRWORK, INFO )
25 *
26 * .. Scalar Arguments ..
27 * CHARACTER JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS
28 * INTEGER INFO, LDU1, LDU2, LDV1T, LDV2T, LRWORK, M, P, Q
29 * ..
30 * .. Array Arguments ..
31 * REAL B11D( * ), B11E( * ), B12D( * ), B12E( * ),
32 * $ B21D( * ), B21E( * ), B22D( * ), B22E( * ),
33 * $ PHI( * ), THETA( * ), RWORK( * )
34 * COMPLEX U1( LDU1, * ), U2( LDU2, * ), V1T( LDV1T, * ),
35 * $ V2T( LDV2T, * )
36 * ..
37 *
38 *
39 *> \par Purpose:
40 * =============
41 *>
42 *> \verbatim
43 *>
44 *> CBBCSD computes the CS decomposition of a unitary matrix in
45 *> bidiagonal-block form,
46 *>
47 *>
48 *> [ B11 | B12 0 0 ]
49 *> [ 0 | 0 -I 0 ]
50 *> X = [----------------]
51 *> [ B21 | B22 0 0 ]
52 *> [ 0 | 0 0 I ]
53 *>
54 *> [ C | -S 0 0 ]
55 *> [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H
56 *> = [---------] [---------------] [---------] .
57 *> [ | U2 ] [ S | C 0 0 ] [ | V2 ]
58 *> [ 0 | 0 0 I ]
59 *>
60 *> X is M-by-M, its top-left block is P-by-Q, and Q must be no larger
61 *> than P, M-P, or M-Q. (If Q is not the smallest index, then X must be
62 *> transposed and/or permuted. This can be done in constant time using
63 *> the TRANS and SIGNS options. See CUNCSD for details.)
64 *>
65 *> The bidiagonal matrices B11, B12, B21, and B22 are represented
66 *> implicitly by angles THETA(1:Q) and PHI(1:Q-1).
67 *>
68 *> The unitary matrices U1, U2, V1T, and V2T are input/output.
69 *> The input matrices are pre- or post-multiplied by the appropriate
70 *> singular vector matrices.
71 *> \endverbatim
72 *
73 * Arguments:
74 * ==========
75 *
76 *> \param[in] JOBU1
77 *> \verbatim
78 *> JOBU1 is CHARACTER
79 *> = 'Y': U1 is updated;
80 *> otherwise: U1 is not updated.
81 *> \endverbatim
82 *>
83 *> \param[in] JOBU2
84 *> \verbatim
85 *> JOBU2 is CHARACTER
86 *> = 'Y': U2 is updated;
87 *> otherwise: U2 is not updated.
88 *> \endverbatim
89 *>
90 *> \param[in] JOBV1T
91 *> \verbatim
92 *> JOBV1T is CHARACTER
93 *> = 'Y': V1T is updated;
94 *> otherwise: V1T is not updated.
95 *> \endverbatim
96 *>
97 *> \param[in] JOBV2T
98 *> \verbatim
99 *> JOBV2T is CHARACTER
100 *> = 'Y': V2T is updated;
101 *> otherwise: V2T is not updated.
102 *> \endverbatim
103 *>
104 *> \param[in] TRANS
105 *> \verbatim
106 *> TRANS is CHARACTER
107 *> = 'T': X, U1, U2, V1T, and V2T are stored in row-major
108 *> order;
109 *> otherwise: X, U1, U2, V1T, and V2T are stored in column-
110 *> major order.
111 *> \endverbatim
112 *>
113 *> \param[in] M
114 *> \verbatim
115 *> M is INTEGER
116 *> The number of rows and columns in X, the unitary matrix in
117 *> bidiagonal-block form.
118 *> \endverbatim
119 *>
120 *> \param[in] P
121 *> \verbatim
122 *> P is INTEGER
123 *> The number of rows in the top-left block of X. 0 <= P <= M.
124 *> \endverbatim
125 *>
126 *> \param[in] Q
127 *> \verbatim
128 *> Q is INTEGER
129 *> The number of columns in the top-left block of X.
130 *> 0 <= Q <= MIN(P,M-P,M-Q).
131 *> \endverbatim
132 *>
133 *> \param[in,out] THETA
134 *> \verbatim
135 *> THETA is REAL array, dimension (Q)
136 *> On entry, the angles THETA(1),...,THETA(Q) that, along with
137 *> PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block
138 *> form. On exit, the angles whose cosines and sines define the
139 *> diagonal blocks in the CS decomposition.
140 *> \endverbatim
141 *>
142 *> \param[in,out] PHI
143 *> \verbatim
144 *> PHI is REAL array, dimension (Q-1)
145 *> The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,
146 *> THETA(Q), define the matrix in bidiagonal-block form.
147 *> \endverbatim
148 *>
149 *> \param[in,out] U1
150 *> \verbatim
151 *> U1 is COMPLEX array, dimension (LDU1,P)
152 *> On entry, an LDU1-by-P matrix. On exit, U1 is postmultiplied
153 *> by the left singular vector matrix common to [ B11 ; 0 ] and
154 *> [ B12 0 0 ; 0 -I 0 0 ].
155 *> \endverbatim
156 *>
157 *> \param[in] LDU1
158 *> \verbatim
159 *> LDU1 is INTEGER
160 *> The leading dimension of the array U1.
161 *> \endverbatim
162 *>
163 *> \param[in,out] U2
164 *> \verbatim
165 *> U2 is COMPLEX array, dimension (LDU2,M-P)
166 *> On entry, an LDU2-by-(M-P) matrix. On exit, U2 is
167 *> postmultiplied by the left singular vector matrix common to
168 *> [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ].
169 *> \endverbatim
170 *>
171 *> \param[in] LDU2
172 *> \verbatim
173 *> LDU2 is INTEGER
174 *> The leading dimension of the array U2.
175 *> \endverbatim
176 *>
177 *> \param[in,out] V1T
178 *> \verbatim
179 *> V1T is COMPLEX array, dimension (LDV1T,Q)
180 *> On entry, a LDV1T-by-Q matrix. On exit, V1T is premultiplied
181 *> by the conjugate transpose of the right singular vector
182 *> matrix common to [ B11 ; 0 ] and [ B21 ; 0 ].
183 *> \endverbatim
184 *>
185 *> \param[in] LDV1T
186 *> \verbatim
187 *> LDV1T is INTEGER
188 *> The leading dimension of the array V1T.
189 *> \endverbatim
190 *>
191 *> \param[in,out] V2T
192 *> \verbatim
193 *> V2T is COMPLEX array, dimenison (LDV2T,M-Q)
194 *> On entry, a LDV2T-by-(M-Q) matrix. On exit, V2T is
195 *> premultiplied by the conjugate transpose of the right
196 *> singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and
197 *> [ B22 0 0 ; 0 0 I ].
198 *> \endverbatim
199 *>
200 *> \param[in] LDV2T
201 *> \verbatim
202 *> LDV2T is INTEGER
203 *> The leading dimension of the array V2T.
204 *> \endverbatim
205 *>
206 *> \param[out] B11D
207 *> \verbatim
208 *> B11D is REAL array, dimension (Q)
209 *> When CBBCSD converges, B11D contains the cosines of THETA(1),
210 *> ..., THETA(Q). If CBBCSD fails to converge, then B11D
211 *> contains the diagonal of the partially reduced top-left
212 *> block.
213 *> \endverbatim
214 *>
215 *> \param[out] B11E
216 *> \verbatim
217 *> B11E is REAL array, dimension (Q-1)
218 *> When CBBCSD converges, B11E contains zeros. If CBBCSD fails
219 *> to converge, then B11E contains the superdiagonal of the
220 *> partially reduced top-left block.
221 *> \endverbatim
222 *>
223 *> \param[out] B12D
224 *> \verbatim
225 *> B12D is REAL array, dimension (Q)
226 *> When CBBCSD converges, B12D contains the negative sines of
227 *> THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
228 *> B12D contains the diagonal of the partially reduced top-right
229 *> block.
230 *> \endverbatim
231 *>
232 *> \param[out] B12E
233 *> \verbatim
234 *> B12E is REAL array, dimension (Q-1)
235 *> When CBBCSD converges, B12E contains zeros. If CBBCSD fails
236 *> to converge, then B12E contains the subdiagonal of the
237 *> partially reduced top-right block.
238 *> \endverbatim
239 *>
240 *> \param[out] B21D
241 *> \verbatim
242 *> B21D is REAL array, dimension (Q)
243 *> When CBBCSD converges, B21D contains the negative sines of
244 *> THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
245 *> B21D contains the diagonal of the partially reduced bottom-left
246 *> block.
247 *> \endverbatim
248 *>
249 *> \param[out] B21E
250 *> \verbatim
251 *> B21E is REAL array, dimension (Q-1)
252 *> When CBBCSD converges, B21E contains zeros. If CBBCSD fails
253 *> to converge, then B21E contains the subdiagonal of the
254 *> partially reduced bottom-left block.
255 *> \endverbatim
256 *>
257 *> \param[out] B22D
258 *> \verbatim
259 *> B22D is REAL array, dimension (Q)
260 *> When CBBCSD converges, B22D contains the negative sines of
261 *> THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
262 *> B22D contains the diagonal of the partially reduced bottom-right
263 *> block.
264 *> \endverbatim
265 *>
266 *> \param[out] B22E
267 *> \verbatim
268 *> B22E is REAL array, dimension (Q-1)
269 *> When CBBCSD converges, B22E contains zeros. If CBBCSD fails
270 *> to converge, then B22E contains the subdiagonal of the
271 *> partially reduced bottom-right block.
272 *> \endverbatim
273 *>
274 *> \param[out] RWORK
275 *> \verbatim
276 *> RWORK is REAL array, dimension (MAX(1,LWORK))
277 *> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
278 *> \endverbatim
279 *>
280 *> \param[in] LRWORK
281 *> \verbatim
282 *> LRWORK is INTEGER
283 *> The dimension of the array RWORK. LRWORK >= MAX(1,8*Q).
284 *>
285 *> If LRWORK = -1, then a workspace query is assumed; the
286 *> routine only calculates the optimal size of the RWORK array,
287 *> returns this value as the first entry of the work array, and
288 *> no error message related to LRWORK is issued by XERBLA.
289 *> \endverbatim
290 *>
291 *> \param[out] INFO
292 *> \verbatim
293 *> INFO is INTEGER
294 *> = 0: successful exit.
295 *> < 0: if INFO = -i, the i-th argument had an illegal value.
296 *> > 0: if CBBCSD did not converge, INFO specifies the number
297 *> of nonzero entries in PHI, and B11D, B11E, etc.,
298 *> contain the partially reduced matrix.
299 *> \endverbatim
300 *
301 *> \par Internal Parameters:
302 * =========================
303 *>
304 *> \verbatim
305 *> TOLMUL REAL, default = MAX(10,MIN(100,EPS**(-1/8)))
306 *> TOLMUL controls the convergence criterion of the QR loop.
307 *> Angles THETA(i), PHI(i) are rounded to 0 or PI/2 when they
308 *> are within TOLMUL*EPS of either bound.
309 *> \endverbatim
310 *
311 *> \par References:
312 * ================
313 *>
314 *> [1] Brian D. Sutton. Computing the complete CS decomposition. Numer.
315 *> Algorithms, 50(1):33-65, 2009.
316 *
317 * Authors:
318 * ========
319 *
320 *> \author Univ. of Tennessee
321 *> \author Univ. of California Berkeley
322 *> \author Univ. of Colorado Denver
323 *> \author NAG Ltd.
324 *
325 *> \date November 2011
326 *
327 *> \ingroup complexOTHERcomputational
328 *
329 * =====================================================================
330  SUBROUTINE cbbcsd( JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, M, P, Q,
331  $ theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t,
332  $ v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e,
333  $ b22d, b22e, rwork, lrwork, info )
334 *
335 * -- LAPACK computational routine (version 3.4.0) --
336 * -- LAPACK is a software package provided by Univ. of Tennessee, --
337 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
338 * November 2011
339 *
340 * .. Scalar Arguments ..
341  CHARACTER jobu1, jobu2, jobv1t, jobv2t, trans
342  INTEGER info, ldu1, ldu2, ldv1t, ldv2t, lrwork, m, p, q
343 * ..
344 * .. Array Arguments ..
345  REAL b11d( * ), b11e( * ), b12d( * ), b12e( * ),
346  $ b21d( * ), b21e( * ), b22d( * ), b22e( * ),
347  $ phi( * ), theta( * ), rwork( * )
348  COMPLEX u1( ldu1, * ), u2( ldu2, * ), v1t( ldv1t, * ),
349  $ v2t( ldv2t, * )
350 * ..
351 *
352 * ===================================================================
353 *
354 * .. Parameters ..
355  INTEGER maxitr
356  parameter( maxitr = 6 )
357  REAL hundred, meighth, one, piover2, ten, zero
358  parameter( hundred = 100.0e0, meighth = -0.125e0,
359  $ one = 1.0e0, piover2 = 1.57079632679489662e0,
360  $ ten = 10.0e0, zero = 0.0e0 )
361  COMPLEX negonecomplex
362  parameter( negonecomplex = (-1.0e0,0.0e0) )
363 * ..
364 * .. Local Scalars ..
365  LOGICAL colmajor, lquery, restart11, restart12,
366  $ restart21, restart22, wantu1, wantu2, wantv1t,
367  $ wantv2t
368  INTEGER i, imin, imax, iter, iu1cs, iu1sn, iu2cs,
369  $ iu2sn, iv1tcs, iv1tsn, iv2tcs, iv2tsn, j,
370  $ lrworkmin, lrworkopt, maxit, mini
371  REAL b11bulge, b12bulge, b21bulge, b22bulge, dummy,
372  $ eps, mu, nu, r, sigma11, sigma21,
373  $ temp, thetamax, thetamin, thresh, tol, tolmul,
374  $ unfl, x1, x2, y1, y2
375 *
376 * .. External Subroutines ..
377  EXTERNAL clasr, cscal, cswap, slartgp, slartgs, slas2,
378  $ xerbla
379 * ..
380 * .. External Functions ..
381  REAL slamch
382  LOGICAL lsame
383  EXTERNAL lsame, slamch
384 * ..
385 * .. Intrinsic Functions ..
386  INTRINSIC abs, atan2, cos, max, min, sin, sqrt
387 * ..
388 * .. Executable Statements ..
389 *
390 * Test input arguments
391 *
392  info = 0
393  lquery = lrwork .EQ. -1
394  wantu1 = lsame( jobu1, 'Y' )
395  wantu2 = lsame( jobu2, 'Y' )
396  wantv1t = lsame( jobv1t, 'Y' )
397  wantv2t = lsame( jobv2t, 'Y' )
398  colmajor = .NOT. lsame( trans, 'T' )
399 *
400  IF( m .LT. 0 ) THEN
401  info = -6
402  ELSE IF( p .LT. 0 .OR. p .GT. m ) THEN
403  info = -7
404  ELSE IF( q .LT. 0 .OR. q .GT. m ) THEN
405  info = -8
406  ELSE IF( q .GT. p .OR. q .GT. m-p .OR. q .GT. m-q ) THEN
407  info = -8
408  ELSE IF( wantu1 .AND. ldu1 .LT. p ) THEN
409  info = -12
410  ELSE IF( wantu2 .AND. ldu2 .LT. m-p ) THEN
411  info = -14
412  ELSE IF( wantv1t .AND. ldv1t .LT. q ) THEN
413  info = -16
414  ELSE IF( wantv2t .AND. ldv2t .LT. m-q ) THEN
415  info = -18
416  END IF
417 *
418 * Quick return if Q = 0
419 *
420  IF( info .EQ. 0 .AND. q .EQ. 0 ) THEN
421  lrworkmin = 1
422  rwork(1) = lrworkmin
423  RETURN
424  END IF
425 *
426 * Compute workspace
427 *
428  IF( info .EQ. 0 ) THEN
429  iu1cs = 1
430  iu1sn = iu1cs + q
431  iu2cs = iu1sn + q
432  iu2sn = iu2cs + q
433  iv1tcs = iu2sn + q
434  iv1tsn = iv1tcs + q
435  iv2tcs = iv1tsn + q
436  iv2tsn = iv2tcs + q
437  lrworkopt = iv2tsn + q - 1
438  lrworkmin = lrworkopt
439  rwork(1) = lrworkopt
440  IF( lrwork .LT. lrworkmin .AND. .NOT. lquery ) THEN
441  info = -28
442  END IF
443  END IF
444 *
445  IF( info .NE. 0 ) THEN
446  CALL xerbla( 'CBBCSD', -info )
447  RETURN
448  ELSE IF( lquery ) THEN
449  RETURN
450  END IF
451 *
452 * Get machine constants
453 *
454  eps = slamch( 'Epsilon' )
455  unfl = slamch( 'Safe minimum' )
456  tolmul = max( ten, min( hundred, eps**meighth ) )
457  tol = tolmul*eps
458  thresh = max( tol, maxitr*q*q*unfl )
459 *
460 * Test for negligible sines or cosines
461 *
462  DO i = 1, q
463  IF( theta(i) .LT. thresh ) THEN
464  theta(i) = zero
465  ELSE IF( theta(i) .GT. piover2-thresh ) THEN
466  theta(i) = piover2
467  END IF
468  END DO
469  DO i = 1, q-1
470  IF( phi(i) .LT. thresh ) THEN
471  phi(i) = zero
472  ELSE IF( phi(i) .GT. piover2-thresh ) THEN
473  phi(i) = piover2
474  END IF
475  END DO
476 *
477 * Initial deflation
478 *
479  imax = q
480  DO WHILE( ( imax .GT. 1 ) .AND. ( phi(imax-1) .EQ. zero ) )
481  imax = imax - 1
482  END DO
483  imin = imax - 1
484  IF ( imin .GT. 1 ) THEN
485  DO WHILE( phi(imin-1) .NE. zero )
486  imin = imin - 1
487  IF ( imin .LE. 1 ) EXIT
488  END DO
489  END IF
490 *
491 * Initialize iteration counter
492 *
493  maxit = maxitr*q*q
494  iter = 0
495 *
496 * Begin main iteration loop
497 *
498  DO WHILE( imax .GT. 1 )
499 *
500 * Compute the matrix entries
501 *
502  b11d(imin) = cos( theta(imin) )
503  b21d(imin) = -sin( theta(imin) )
504  DO i = imin, imax - 1
505  b11e(i) = -sin( theta(i) ) * sin( phi(i) )
506  b11d(i+1) = cos( theta(i+1) ) * cos( phi(i) )
507  b12d(i) = sin( theta(i) ) * cos( phi(i) )
508  b12e(i) = cos( theta(i+1) ) * sin( phi(i) )
509  b21e(i) = -cos( theta(i) ) * sin( phi(i) )
510  b21d(i+1) = -sin( theta(i+1) ) * cos( phi(i) )
511  b22d(i) = cos( theta(i) ) * cos( phi(i) )
512  b22e(i) = -sin( theta(i+1) ) * sin( phi(i) )
513  END DO
514  b12d(imax) = sin( theta(imax) )
515  b22d(imax) = cos( theta(imax) )
516 *
517 * Abort if not converging; otherwise, increment ITER
518 *
519  IF( iter .GT. maxit ) THEN
520  info = 0
521  DO i = 1, q
522  IF( phi(i) .NE. zero )
523  $ info = info + 1
524  END DO
525  RETURN
526  END IF
527 *
528  iter = iter + imax - imin
529 *
530 * Compute shifts
531 *
532  thetamax = theta(imin)
533  thetamin = theta(imin)
534  DO i = imin+1, imax
535  IF( theta(i) > thetamax )
536  $ thetamax = theta(i)
537  IF( theta(i) < thetamin )
538  $ thetamin = theta(i)
539  END DO
540 *
541  IF( thetamax .GT. piover2 - thresh ) THEN
542 *
543 * Zero on diagonals of B11 and B22; induce deflation with a
544 * zero shift
545 *
546  mu = zero
547  nu = one
548 *
549  ELSE IF( thetamin .LT. thresh ) THEN
550 *
551 * Zero on diagonals of B12 and B22; induce deflation with a
552 * zero shift
553 *
554  mu = one
555  nu = zero
556 *
557  ELSE
558 *
559 * Compute shifts for B11 and B21 and use the lesser
560 *
561  CALL slas2( b11d(imax-1), b11e(imax-1), b11d(imax), sigma11,
562  $ dummy )
563  CALL slas2( b21d(imax-1), b21e(imax-1), b21d(imax), sigma21,
564  $ dummy )
565 *
566  IF( sigma11 .LE. sigma21 ) THEN
567  mu = sigma11
568  nu = sqrt( one - mu**2 )
569  IF( mu .LT. thresh ) THEN
570  mu = zero
571  nu = one
572  END IF
573  ELSE
574  nu = sigma21
575  mu = sqrt( 1.0 - nu**2 )
576  IF( nu .LT. thresh ) THEN
577  mu = one
578  nu = zero
579  END IF
580  END IF
581  END IF
582 *
583 * Rotate to produce bulges in B11 and B21
584 *
585  IF( mu .LE. nu ) THEN
586  CALL slartgs( b11d(imin), b11e(imin), mu,
587  $ rwork(iv1tcs+imin-1), rwork(iv1tsn+imin-1) )
588  ELSE
589  CALL slartgs( b21d(imin), b21e(imin), nu,
590  $ rwork(iv1tcs+imin-1), rwork(iv1tsn+imin-1) )
591  END IF
592 *
593  temp = rwork(iv1tcs+imin-1)*b11d(imin) +
594  $ rwork(iv1tsn+imin-1)*b11e(imin)
595  b11e(imin) = rwork(iv1tcs+imin-1)*b11e(imin) -
596  $ rwork(iv1tsn+imin-1)*b11d(imin)
597  b11d(imin) = temp
598  b11bulge = rwork(iv1tsn+imin-1)*b11d(imin+1)
599  b11d(imin+1) = rwork(iv1tcs+imin-1)*b11d(imin+1)
600  temp = rwork(iv1tcs+imin-1)*b21d(imin) +
601  $ rwork(iv1tsn+imin-1)*b21e(imin)
602  b21e(imin) = rwork(iv1tcs+imin-1)*b21e(imin) -
603  $ rwork(iv1tsn+imin-1)*b21d(imin)
604  b21d(imin) = temp
605  b21bulge = rwork(iv1tsn+imin-1)*b21d(imin+1)
606  b21d(imin+1) = rwork(iv1tcs+imin-1)*b21d(imin+1)
607 *
608 * Compute THETA(IMIN)
609 *
610  theta( imin ) = atan2( sqrt( b21d(imin)**2+b21bulge**2 ),
611  $ sqrt( b11d(imin)**2+b11bulge**2 ) )
612 *
613 * Chase the bulges in B11(IMIN+1,IMIN) and B21(IMIN+1,IMIN)
614 *
615  IF( b11d(imin)**2+b11bulge**2 .GT. thresh**2 ) THEN
616  CALL slartgp( b11bulge, b11d(imin), rwork(iu1sn+imin-1),
617  $ rwork(iu1cs+imin-1), r )
618  ELSE IF( mu .LE. nu ) THEN
619  CALL slartgs( b11e( imin ), b11d( imin + 1 ), mu,
620  $ rwork(iu1cs+imin-1), rwork(iu1sn+imin-1) )
621  ELSE
622  CALL slartgs( b12d( imin ), b12e( imin ), nu,
623  $ rwork(iu1cs+imin-1), rwork(iu1sn+imin-1) )
624  END IF
625  IF( b21d(imin)**2+b21bulge**2 .GT. thresh**2 ) THEN
626  CALL slartgp( b21bulge, b21d(imin), rwork(iu2sn+imin-1),
627  $ rwork(iu2cs+imin-1), r )
628  ELSE IF( nu .LT. mu ) THEN
629  CALL slartgs( b21e( imin ), b21d( imin + 1 ), nu,
630  $ rwork(iu2cs+imin-1), rwork(iu2sn+imin-1) )
631  ELSE
632  CALL slartgs( b22d(imin), b22e(imin), mu,
633  $ rwork(iu2cs+imin-1), rwork(iu2sn+imin-1) )
634  END IF
635  rwork(iu2cs+imin-1) = -rwork(iu2cs+imin-1)
636  rwork(iu2sn+imin-1) = -rwork(iu2sn+imin-1)
637 *
638  temp = rwork(iu1cs+imin-1)*b11e(imin) +
639  $ rwork(iu1sn+imin-1)*b11d(imin+1)
640  b11d(imin+1) = rwork(iu1cs+imin-1)*b11d(imin+1) -
641  $ rwork(iu1sn+imin-1)*b11e(imin)
642  b11e(imin) = temp
643  IF( imax .GT. imin+1 ) THEN
644  b11bulge = rwork(iu1sn+imin-1)*b11e(imin+1)
645  b11e(imin+1) = rwork(iu1cs+imin-1)*b11e(imin+1)
646  END IF
647  temp = rwork(iu1cs+imin-1)*b12d(imin) +
648  $ rwork(iu1sn+imin-1)*b12e(imin)
649  b12e(imin) = rwork(iu1cs+imin-1)*b12e(imin) -
650  $ rwork(iu1sn+imin-1)*b12d(imin)
651  b12d(imin) = temp
652  b12bulge = rwork(iu1sn+imin-1)*b12d(imin+1)
653  b12d(imin+1) = rwork(iu1cs+imin-1)*b12d(imin+1)
654  temp = rwork(iu2cs+imin-1)*b21e(imin) +
655  $ rwork(iu2sn+imin-1)*b21d(imin+1)
656  b21d(imin+1) = rwork(iu2cs+imin-1)*b21d(imin+1) -
657  $ rwork(iu2sn+imin-1)*b21e(imin)
658  b21e(imin) = temp
659  IF( imax .GT. imin+1 ) THEN
660  b21bulge = rwork(iu2sn+imin-1)*b21e(imin+1)
661  b21e(imin+1) = rwork(iu2cs+imin-1)*b21e(imin+1)
662  END IF
663  temp = rwork(iu2cs+imin-1)*b22d(imin) +
664  $ rwork(iu2sn+imin-1)*b22e(imin)
665  b22e(imin) = rwork(iu2cs+imin-1)*b22e(imin) -
666  $ rwork(iu2sn+imin-1)*b22d(imin)
667  b22d(imin) = temp
668  b22bulge = rwork(iu2sn+imin-1)*b22d(imin+1)
669  b22d(imin+1) = rwork(iu2cs+imin-1)*b22d(imin+1)
670 *
671 * Inner loop: chase bulges from B11(IMIN,IMIN+2),
672 * B12(IMIN,IMIN+1), B21(IMIN,IMIN+2), and B22(IMIN,IMIN+1) to
673 * bottom-right
674 *
675  DO i = imin+1, imax-1
676 *
677 * Compute PHI(I-1)
678 *
679  x1 = sin(theta(i-1))*b11e(i-1) + cos(theta(i-1))*b21e(i-1)
680  x2 = sin(theta(i-1))*b11bulge + cos(theta(i-1))*b21bulge
681  y1 = sin(theta(i-1))*b12d(i-1) + cos(theta(i-1))*b22d(i-1)
682  y2 = sin(theta(i-1))*b12bulge + cos(theta(i-1))*b22bulge
683 *
684  phi(i-1) = atan2( sqrt(x1**2+x2**2), sqrt(y1**2+y2**2) )
685 *
686 * Determine if there are bulges to chase or if a new direct
687 * summand has been reached
688 *
689  restart11 = b11e(i-1)**2 + b11bulge**2 .LE. thresh**2
690  restart21 = b21e(i-1)**2 + b21bulge**2 .LE. thresh**2
691  restart12 = b12d(i-1)**2 + b12bulge**2 .LE. thresh**2
692  restart22 = b22d(i-1)**2 + b22bulge**2 .LE. thresh**2
693 *
694 * If possible, chase bulges from B11(I-1,I+1), B12(I-1,I),
695 * B21(I-1,I+1), and B22(I-1,I). If necessary, restart bulge-
696 * chasing by applying the original shift again.
697 *
698  IF( .NOT. restart11 .AND. .NOT. restart21 ) THEN
699  CALL slartgp( x2, x1, rwork(iv1tsn+i-1),
700  $ rwork(iv1tcs+i-1), r )
701  ELSE IF( .NOT. restart11 .AND. restart21 ) THEN
702  CALL slartgp( b11bulge, b11e(i-1), rwork(iv1tsn+i-1),
703  $ rwork(iv1tcs+i-1), r )
704  ELSE IF( restart11 .AND. .NOT. restart21 ) THEN
705  CALL slartgp( b21bulge, b21e(i-1), rwork(iv1tsn+i-1),
706  $ rwork(iv1tcs+i-1), r )
707  ELSE IF( mu .LE. nu ) THEN
708  CALL slartgs( b11d(i), b11e(i), mu, rwork(iv1tcs+i-1),
709  $ rwork(iv1tsn+i-1) )
710  ELSE
711  CALL slartgs( b21d(i), b21e(i), nu, rwork(iv1tcs+i-1),
712  $ rwork(iv1tsn+i-1) )
713  END IF
714  rwork(iv1tcs+i-1) = -rwork(iv1tcs+i-1)
715  rwork(iv1tsn+i-1) = -rwork(iv1tsn+i-1)
716  IF( .NOT. restart12 .AND. .NOT. restart22 ) THEN
717  CALL slartgp( y2, y1, rwork(iv2tsn+i-1-1),
718  $ rwork(iv2tcs+i-1-1), r )
719  ELSE IF( .NOT. restart12 .AND. restart22 ) THEN
720  CALL slartgp( b12bulge, b12d(i-1), rwork(iv2tsn+i-1-1),
721  $ rwork(iv2tcs+i-1-1), r )
722  ELSE IF( restart12 .AND. .NOT. restart22 ) THEN
723  CALL slartgp( b22bulge, b22d(i-1), rwork(iv2tsn+i-1-1),
724  $ rwork(iv2tcs+i-1-1), r )
725  ELSE IF( nu .LT. mu ) THEN
726  CALL slartgs( b12e(i-1), b12d(i), nu,
727  $ rwork(iv2tcs+i-1-1), rwork(iv2tsn+i-1-1) )
728  ELSE
729  CALL slartgs( b22e(i-1), b22d(i), mu,
730  $ rwork(iv2tcs+i-1-1), rwork(iv2tsn+i-1-1) )
731  END IF
732 *
733  temp = rwork(iv1tcs+i-1)*b11d(i) + rwork(iv1tsn+i-1)*b11e(i)
734  b11e(i) = rwork(iv1tcs+i-1)*b11e(i) -
735  $ rwork(iv1tsn+i-1)*b11d(i)
736  b11d(i) = temp
737  b11bulge = rwork(iv1tsn+i-1)*b11d(i+1)
738  b11d(i+1) = rwork(iv1tcs+i-1)*b11d(i+1)
739  temp = rwork(iv1tcs+i-1)*b21d(i) + rwork(iv1tsn+i-1)*b21e(i)
740  b21e(i) = rwork(iv1tcs+i-1)*b21e(i) -
741  $ rwork(iv1tsn+i-1)*b21d(i)
742  b21d(i) = temp
743  b21bulge = rwork(iv1tsn+i-1)*b21d(i+1)
744  b21d(i+1) = rwork(iv1tcs+i-1)*b21d(i+1)
745  temp = rwork(iv2tcs+i-1-1)*b12e(i-1) +
746  $ rwork(iv2tsn+i-1-1)*b12d(i)
747  b12d(i) = rwork(iv2tcs+i-1-1)*b12d(i) -
748  $ rwork(iv2tsn+i-1-1)*b12e(i-1)
749  b12e(i-1) = temp
750  b12bulge = rwork(iv2tsn+i-1-1)*b12e(i)
751  b12e(i) = rwork(iv2tcs+i-1-1)*b12e(i)
752  temp = rwork(iv2tcs+i-1-1)*b22e(i-1) +
753  $ rwork(iv2tsn+i-1-1)*b22d(i)
754  b22d(i) = rwork(iv2tcs+i-1-1)*b22d(i) -
755  $ rwork(iv2tsn+i-1-1)*b22e(i-1)
756  b22e(i-1) = temp
757  b22bulge = rwork(iv2tsn+i-1-1)*b22e(i)
758  b22e(i) = rwork(iv2tcs+i-1-1)*b22e(i)
759 *
760 * Compute THETA(I)
761 *
762  x1 = cos(phi(i-1))*b11d(i) + sin(phi(i-1))*b12e(i-1)
763  x2 = cos(phi(i-1))*b11bulge + sin(phi(i-1))*b12bulge
764  y1 = cos(phi(i-1))*b21d(i) + sin(phi(i-1))*b22e(i-1)
765  y2 = cos(phi(i-1))*b21bulge + sin(phi(i-1))*b22bulge
766 *
767  theta(i) = atan2( sqrt(y1**2+y2**2), sqrt(x1**2+x2**2) )
768 *
769 * Determine if there are bulges to chase or if a new direct
770 * summand has been reached
771 *
772  restart11 = b11d(i)**2 + b11bulge**2 .LE. thresh**2
773  restart12 = b12e(i-1)**2 + b12bulge**2 .LE. thresh**2
774  restart21 = b21d(i)**2 + b21bulge**2 .LE. thresh**2
775  restart22 = b22e(i-1)**2 + b22bulge**2 .LE. thresh**2
776 *
777 * If possible, chase bulges from B11(I+1,I), B12(I+1,I-1),
778 * B21(I+1,I), and B22(I+1,I-1). If necessary, restart bulge-
779 * chasing by applying the original shift again.
780 *
781  IF( .NOT. restart11 .AND. .NOT. restart12 ) THEN
782  CALL slartgp( x2, x1, rwork(iu1sn+i-1), rwork(iu1cs+i-1),
783  $ r )
784  ELSE IF( .NOT. restart11 .AND. restart12 ) THEN
785  CALL slartgp( b11bulge, b11d(i), rwork(iu1sn+i-1),
786  $ rwork(iu1cs+i-1), r )
787  ELSE IF( restart11 .AND. .NOT. restart12 ) THEN
788  CALL slartgp( b12bulge, b12e(i-1), rwork(iu1sn+i-1),
789  $ rwork(iu1cs+i-1), r )
790  ELSE IF( mu .LE. nu ) THEN
791  CALL slartgs( b11e(i), b11d(i+1), mu, rwork(iu1cs+i-1),
792  $ rwork(iu1sn+i-1) )
793  ELSE
794  CALL slartgs( b12d(i), b12e(i), nu, rwork(iu1cs+i-1),
795  $ rwork(iu1sn+i-1) )
796  END IF
797  IF( .NOT. restart21 .AND. .NOT. restart22 ) THEN
798  CALL slartgp( y2, y1, rwork(iu2sn+i-1), rwork(iu2cs+i-1),
799  $ r )
800  ELSE IF( .NOT. restart21 .AND. restart22 ) THEN
801  CALL slartgp( b21bulge, b21d(i), rwork(iu2sn+i-1),
802  $ rwork(iu2cs+i-1), r )
803  ELSE IF( restart21 .AND. .NOT. restart22 ) THEN
804  CALL slartgp( b22bulge, b22e(i-1), rwork(iu2sn+i-1),
805  $ rwork(iu2cs+i-1), r )
806  ELSE IF( nu .LT. mu ) THEN
807  CALL slartgs( b21e(i), b21e(i+1), nu, rwork(iu2cs+i-1),
808  $ rwork(iu2sn+i-1) )
809  ELSE
810  CALL slartgs( b22d(i), b22e(i), mu, rwork(iu2cs+i-1),
811  $ rwork(iu2sn+i-1) )
812  END IF
813  rwork(iu2cs+i-1) = -rwork(iu2cs+i-1)
814  rwork(iu2sn+i-1) = -rwork(iu2sn+i-1)
815 *
816  temp = rwork(iu1cs+i-1)*b11e(i) + rwork(iu1sn+i-1)*b11d(i+1)
817  b11d(i+1) = rwork(iu1cs+i-1)*b11d(i+1) -
818  $ rwork(iu1sn+i-1)*b11e(i)
819  b11e(i) = temp
820  IF( i .LT. imax - 1 ) THEN
821  b11bulge = rwork(iu1sn+i-1)*b11e(i+1)
822  b11e(i+1) = rwork(iu1cs+i-1)*b11e(i+1)
823  END IF
824  temp = rwork(iu2cs+i-1)*b21e(i) + rwork(iu2sn+i-1)*b21d(i+1)
825  b21d(i+1) = rwork(iu2cs+i-1)*b21d(i+1) -
826  $ rwork(iu2sn+i-1)*b21e(i)
827  b21e(i) = temp
828  IF( i .LT. imax - 1 ) THEN
829  b21bulge = rwork(iu2sn+i-1)*b21e(i+1)
830  b21e(i+1) = rwork(iu2cs+i-1)*b21e(i+1)
831  END IF
832  temp = rwork(iu1cs+i-1)*b12d(i) + rwork(iu1sn+i-1)*b12e(i)
833  b12e(i) = rwork(iu1cs+i-1)*b12e(i) -
834  $ rwork(iu1sn+i-1)*b12d(i)
835  b12d(i) = temp
836  b12bulge = rwork(iu1sn+i-1)*b12d(i+1)
837  b12d(i+1) = rwork(iu1cs+i-1)*b12d(i+1)
838  temp = rwork(iu2cs+i-1)*b22d(i) + rwork(iu2sn+i-1)*b22e(i)
839  b22e(i) = rwork(iu2cs+i-1)*b22e(i) -
840  $ rwork(iu2sn+i-1)*b22d(i)
841  b22d(i) = temp
842  b22bulge = rwork(iu2sn+i-1)*b22d(i+1)
843  b22d(i+1) = rwork(iu2cs+i-1)*b22d(i+1)
844 *
845  END DO
846 *
847 * Compute PHI(IMAX-1)
848 *
849  x1 = sin(theta(imax-1))*b11e(imax-1) +
850  $ cos(theta(imax-1))*b21e(imax-1)
851  y1 = sin(theta(imax-1))*b12d(imax-1) +
852  $ cos(theta(imax-1))*b22d(imax-1)
853  y2 = sin(theta(imax-1))*b12bulge + cos(theta(imax-1))*b22bulge
854 *
855  phi(imax-1) = atan2( abs(x1), sqrt(y1**2+y2**2) )
856 *
857 * Chase bulges from B12(IMAX-1,IMAX) and B22(IMAX-1,IMAX)
858 *
859  restart12 = b12d(imax-1)**2 + b12bulge**2 .LE. thresh**2
860  restart22 = b22d(imax-1)**2 + b22bulge**2 .LE. thresh**2
861 *
862  IF( .NOT. restart12 .AND. .NOT. restart22 ) THEN
863  CALL slartgp( y2, y1, rwork(iv2tsn+imax-1-1),
864  $ rwork(iv2tcs+imax-1-1), r )
865  ELSE IF( .NOT. restart12 .AND. restart22 ) THEN
866  CALL slartgp( b12bulge, b12d(imax-1),
867  $ rwork(iv2tsn+imax-1-1),
868  $ rwork(iv2tcs+imax-1-1), r )
869  ELSE IF( restart12 .AND. .NOT. restart22 ) THEN
870  CALL slartgp( b22bulge, b22d(imax-1),
871  $ rwork(iv2tsn+imax-1-1),
872  $ rwork(iv2tcs+imax-1-1), r )
873  ELSE IF( nu .LT. mu ) THEN
874  CALL slartgs( b12e(imax-1), b12d(imax), nu,
875  $ rwork(iv2tcs+imax-1-1),
876  $ rwork(iv2tsn+imax-1-1) )
877  ELSE
878  CALL slartgs( b22e(imax-1), b22d(imax), mu,
879  $ rwork(iv2tcs+imax-1-1),
880  $ rwork(iv2tsn+imax-1-1) )
881  END IF
882 *
883  temp = rwork(iv2tcs+imax-1-1)*b12e(imax-1) +
884  $ rwork(iv2tsn+imax-1-1)*b12d(imax)
885  b12d(imax) = rwork(iv2tcs+imax-1-1)*b12d(imax) -
886  $ rwork(iv2tsn+imax-1-1)*b12e(imax-1)
887  b12e(imax-1) = temp
888  temp = rwork(iv2tcs+imax-1-1)*b22e(imax-1) +
889  $ rwork(iv2tsn+imax-1-1)*b22d(imax)
890  b22d(imax) = rwork(iv2tcs+imax-1-1)*b22d(imax) -
891  $ rwork(iv2tsn+imax-1-1)*b22e(imax-1)
892  b22e(imax-1) = temp
893 *
894 * Update singular vectors
895 *
896  IF( wantu1 ) THEN
897  IF( colmajor ) THEN
898  CALL clasr( 'R', 'V', 'F', p, imax-imin+1,
899  $ rwork(iu1cs+imin-1), rwork(iu1sn+imin-1),
900  $ u1(1,imin), ldu1 )
901  ELSE
902  CALL clasr( 'L', 'V', 'F', imax-imin+1, p,
903  $ rwork(iu1cs+imin-1), rwork(iu1sn+imin-1),
904  $ u1(imin,1), ldu1 )
905  END IF
906  END IF
907  IF( wantu2 ) THEN
908  IF( colmajor ) THEN
909  CALL clasr( 'R', 'V', 'F', m-p, imax-imin+1,
910  $ rwork(iu2cs+imin-1), rwork(iu2sn+imin-1),
911  $ u2(1,imin), ldu2 )
912  ELSE
913  CALL clasr( 'L', 'V', 'F', imax-imin+1, m-p,
914  $ rwork(iu2cs+imin-1), rwork(iu2sn+imin-1),
915  $ u2(imin,1), ldu2 )
916  END IF
917  END IF
918  IF( wantv1t ) THEN
919  IF( colmajor ) THEN
920  CALL clasr( 'L', 'V', 'F', imax-imin+1, q,
921  $ rwork(iv1tcs+imin-1), rwork(iv1tsn+imin-1),
922  $ v1t(imin,1), ldv1t )
923  ELSE
924  CALL clasr( 'R', 'V', 'F', q, imax-imin+1,
925  $ rwork(iv1tcs+imin-1), rwork(iv1tsn+imin-1),
926  $ v1t(1,imin), ldv1t )
927  END IF
928  END IF
929  IF( wantv2t ) THEN
930  IF( colmajor ) THEN
931  CALL clasr( 'L', 'V', 'F', imax-imin+1, m-q,
932  $ rwork(iv2tcs+imin-1), rwork(iv2tsn+imin-1),
933  $ v2t(imin,1), ldv2t )
934  ELSE
935  CALL clasr( 'R', 'V', 'F', m-q, imax-imin+1,
936  $ rwork(iv2tcs+imin-1), rwork(iv2tsn+imin-1),
937  $ v2t(1,imin), ldv2t )
938  END IF
939  END IF
940 *
941 * Fix signs on B11(IMAX-1,IMAX) and B21(IMAX-1,IMAX)
942 *
943  IF( b11e(imax-1)+b21e(imax-1) .GT. 0 ) THEN
944  b11d(imax) = -b11d(imax)
945  b21d(imax) = -b21d(imax)
946  IF( wantv1t ) THEN
947  IF( colmajor ) THEN
948  CALL cscal( q, negonecomplex, v1t(imax,1), ldv1t )
949  ELSE
950  CALL cscal( q, negonecomplex, v1t(1,imax), 1 )
951  END IF
952  END IF
953  END IF
954 *
955 * Compute THETA(IMAX)
956 *
957  x1 = cos(phi(imax-1))*b11d(imax) +
958  $ sin(phi(imax-1))*b12e(imax-1)
959  y1 = cos(phi(imax-1))*b21d(imax) +
960  $ sin(phi(imax-1))*b22e(imax-1)
961 *
962  theta(imax) = atan2( abs(y1), abs(x1) )
963 *
964 * Fix signs on B11(IMAX,IMAX), B12(IMAX,IMAX-1), B21(IMAX,IMAX),
965 * and B22(IMAX,IMAX-1)
966 *
967  IF( b11d(imax)+b12e(imax-1) .LT. 0 ) THEN
968  b12d(imax) = -b12d(imax)
969  IF( wantu1 ) THEN
970  IF( colmajor ) THEN
971  CALL cscal( p, negonecomplex, u1(1,imax), 1 )
972  ELSE
973  CALL cscal( p, negonecomplex, u1(imax,1), ldu1 )
974  END IF
975  END IF
976  END IF
977  IF( b21d(imax)+b22e(imax-1) .GT. 0 ) THEN
978  b22d(imax) = -b22d(imax)
979  IF( wantu2 ) THEN
980  IF( colmajor ) THEN
981  CALL cscal( m-p, negonecomplex, u2(1,imax), 1 )
982  ELSE
983  CALL cscal( m-p, negonecomplex, u2(imax,1), ldu2 )
984  END IF
985  END IF
986  END IF
987 *
988 * Fix signs on B12(IMAX,IMAX) and B22(IMAX,IMAX)
989 *
990  IF( b12d(imax)+b22d(imax) .LT. 0 ) THEN
991  IF( wantv2t ) THEN
992  IF( colmajor ) THEN
993  CALL cscal( m-q, negonecomplex, v2t(imax,1), ldv2t )
994  ELSE
995  CALL cscal( m-q, negonecomplex, v2t(1,imax), 1 )
996  END IF
997  END IF
998  END IF
999 *
1000 * Test for negligible sines or cosines
1001 *
1002  DO i = imin, imax
1003  IF( theta(i) .LT. thresh ) THEN
1004  theta(i) = zero
1005  ELSE IF( theta(i) .GT. piover2-thresh ) THEN
1006  theta(i) = piover2
1007  END IF
1008  END DO
1009  DO i = imin, imax-1
1010  IF( phi(i) .LT. thresh ) THEN
1011  phi(i) = zero
1012  ELSE IF( phi(i) .GT. piover2-thresh ) THEN
1013  phi(i) = piover2
1014  END IF
1015  END DO
1016 *
1017 * Deflate
1018 *
1019  IF (imax .GT. 1) THEN
1020  DO WHILE( phi(imax-1) .EQ. zero )
1021  imax = imax - 1
1022  IF (imax .LE. 1) EXIT
1023  END DO
1024  END IF
1025  IF( imin .GT. imax - 1 )
1026  $ imin = imax - 1
1027  IF (imin .GT. 1) THEN
1028  DO WHILE (phi(imin-1) .NE. zero)
1029  imin = imin - 1
1030  IF (imin .LE. 1) EXIT
1031  END DO
1032  END IF
1033 *
1034 * Repeat main iteration loop
1035 *
1036  END DO
1037 *
1038 * Postprocessing: order THETA from least to greatest
1039 *
1040  DO i = 1, q
1041 *
1042  mini = i
1043  thetamin = theta(i)
1044  DO j = i+1, q
1045  IF( theta(j) .LT. thetamin ) THEN
1046  mini = j
1047  thetamin = theta(j)
1048  END IF
1049  END DO
1050 *
1051  IF( mini .NE. i ) THEN
1052  theta(mini) = theta(i)
1053  theta(i) = thetamin
1054  IF( colmajor ) THEN
1055  IF( wantu1 )
1056  $ CALL cswap( p, u1(1,i), 1, u1(1,mini), 1 )
1057  IF( wantu2 )
1058  $ CALL cswap( m-p, u2(1,i), 1, u2(1,mini), 1 )
1059  IF( wantv1t )
1060  $ CALL cswap( q, v1t(i,1), ldv1t, v1t(mini,1), ldv1t )
1061  IF( wantv2t )
1062  $ CALL cswap( m-q, v2t(i,1), ldv2t, v2t(mini,1),
1063  $ ldv2t )
1064  ELSE
1065  IF( wantu1 )
1066  $ CALL cswap( p, u1(i,1), ldu1, u1(mini,1), ldu1 )
1067  IF( wantu2 )
1068  $ CALL cswap( m-p, u2(i,1), ldu2, u2(mini,1), ldu2 )
1069  IF( wantv1t )
1070  $ CALL cswap( q, v1t(1,i), 1, v1t(1,mini), 1 )
1071  IF( wantv2t )
1072  $ CALL cswap( m-q, v2t(1,i), 1, v2t(1,mini), 1 )
1073  END IF
1074  END IF
1075 *
1076  END DO
1077 *
1078  RETURN
1079 *
1080 * End of CBBCSD
1081 *
1082  END
1083 
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
subroutine slartgp(F, G, CS, SN, R)
SLARTGP
Definition: slartgp.f:96
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:54
subroutine clasr(SIDE, PIVOT, DIRECT, M, N, C, S, A, LDA)
CLASR
Definition: clasr.f:201
subroutine slas2(F, G, H, SSMIN, SSMAX)
SLAS2
Definition: slas2.f:108
subroutine cbbcsd(JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, M, P, Q, THETA, PHI, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, B11D, B11E, B12D, B12E, B21D, B21E, B22D, B22E, RWORK, LRWORK, INFO)
CBBCSD
Definition: cbbcsd.f:330
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:61
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:51
subroutine slartgs(X, Y, SIGMA, CS, SN)
SLARTGS
Definition: slartgs.f:91
subroutine cscal(N, CA, CX, INCX)
CSCAL
Definition: cscal.f:53