LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
 recursive subroutine zuncsd ( character JOBU1, character JOBU2, character JOBV1T, character JOBV2T, character TRANS, character SIGNS, integer M, integer P, integer Q, complex*16, dimension( ldx11, * ) X11, integer LDX11, complex*16, dimension( ldx12, * ) X12, integer LDX12, complex*16, dimension( ldx21, * ) X21, integer LDX21, complex*16, dimension( ldx22, * ) X22, integer LDX22, double precision, dimension( * ) THETA, complex*16, dimension( ldu1, * ) U1, integer LDU1, complex*16, dimension( ldu2, * ) U2, integer LDU2, complex*16, dimension( ldv1t, * ) V1T, integer LDV1T, complex*16, dimension( ldv2t, * ) V2T, integer LDV2T, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer LRWORK, integer, dimension( * ) IWORK, integer INFO )

ZUNCSD

Purpose:
``` ZUNCSD computes the CS decomposition of an M-by-M partitioned
unitary matrix X:

[  I  0  0 |  0  0  0 ]
[  0  C  0 |  0 -S  0 ]
[ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**H
X = [-----------] = [---------] [---------------------] [---------]   .
[ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]
[  0  S  0 |  0  C  0 ]
[  0  0  I |  0  0  0 ]

X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P,
(M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are
R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in
which R = MIN(P,M-P,Q,M-Q).```
Parameters
 [in] JOBU1 ``` JOBU1 is CHARACTER = 'Y': U1 is computed; otherwise: U1 is not computed.``` [in] JOBU2 ``` JOBU2 is CHARACTER = 'Y': U2 is computed; otherwise: U2 is not computed.``` [in] JOBV1T ``` JOBV1T is CHARACTER = 'Y': V1T is computed; otherwise: V1T is not computed.``` [in] JOBV2T ``` JOBV2T is CHARACTER = 'Y': V2T is computed; otherwise: V2T is not computed.``` [in] TRANS ``` TRANS is CHARACTER = 'T': X, U1, U2, V1T, and V2T are stored in row-major order; otherwise: X, U1, U2, V1T, and V2T are stored in column- major order.``` [in] SIGNS ``` SIGNS is CHARACTER = 'O': The lower-left block is made nonpositive (the "other" convention); otherwise: The upper-right block is made nonpositive (the "default" convention).``` [in] M ``` M is INTEGER The number of rows and columns in X.``` [in] P ``` P is INTEGER The number of rows in X11 and X12. 0 <= P <= M.``` [in] Q ``` Q is INTEGER The number of columns in X11 and X21. 0 <= Q <= M.``` [in,out] X11 ``` X11 is COMPLEX*16 array, dimension (LDX11,Q) On entry, part of the unitary matrix whose CSD is desired.``` [in] LDX11 ``` LDX11 is INTEGER The leading dimension of X11. LDX11 >= MAX(1,P).``` [in,out] X12 ``` X12 is COMPLEX*16 array, dimension (LDX12,M-Q) On entry, part of the unitary matrix whose CSD is desired.``` [in] LDX12 ``` LDX12 is INTEGER The leading dimension of X12. LDX12 >= MAX(1,P).``` [in,out] X21 ``` X21 is COMPLEX*16 array, dimension (LDX21,Q) On entry, part of the unitary matrix whose CSD is desired.``` [in] LDX21 ``` LDX21 is INTEGER The leading dimension of X11. LDX21 >= MAX(1,M-P).``` [in,out] X22 ``` X22 is COMPLEX*16 array, dimension (LDX22,M-Q) On entry, part of the unitary matrix whose CSD is desired.``` [in] LDX22 ``` LDX22 is INTEGER The leading dimension of X11. LDX22 >= MAX(1,M-P).``` [out] THETA ``` THETA is DOUBLE PRECISION array, dimension (R), in which R = MIN(P,M-P,Q,M-Q). C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ).``` [out] U1 ``` U1 is COMPLEX*16 array, dimension (P) If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1.``` [in] LDU1 ``` LDU1 is INTEGER The leading dimension of U1. If JOBU1 = 'Y', LDU1 >= MAX(1,P).``` [out] U2 ``` U2 is COMPLEX*16 array, dimension (M-P) If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary matrix U2.``` [in] LDU2 ``` LDU2 is INTEGER The leading dimension of U2. If JOBU2 = 'Y', LDU2 >= MAX(1,M-P).``` [out] V1T ``` V1T is COMPLEX*16 array, dimension (Q) If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary matrix V1**H.``` [in] LDV1T ``` LDV1T is INTEGER The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >= MAX(1,Q).``` [out] V2T ``` V2T is COMPLEX*16 array, dimension (M-Q) If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) unitary matrix V2**H.``` [in] LDV2T ``` LDV2T is INTEGER The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >= MAX(1,M-Q).``` [out] WORK ``` WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the work array, and no error message related to LWORK is issued by XERBLA.``` [out] RWORK ``` RWORK is DOUBLE PRECISION array, dimension MAX(1,LRWORK) On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK. If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1), ..., PHI(R-1) that, together with THETA(1), ..., THETA(R), define the matrix in intermediate bidiagonal-block form remaining after nonconvergence. INFO specifies the number of nonzero PHI's.``` [in] LRWORK ``` LRWORK is INTEGER The dimension of the array RWORK. If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the RWORK array, returns this value as the first entry of the work array, and no error message related to LRWORK is issued by XERBLA.``` [out] IWORK ` IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))` [out] INFO ``` INFO is INTEGER = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: ZBBCSD did not converge. See the description of RWORK above for details.```
References:
[1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009.
Date
November 2013

Definition at line 322 of file zuncsd.f.

322 *
323 * -- LAPACK computational routine (version 3.5.0) --
324 * -- LAPACK is a software package provided by Univ. of Tennessee, --
325 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
326 * November 2013
327 *
328 * .. Scalar Arguments ..
329  CHARACTER jobu1, jobu2, jobv1t, jobv2t, signs, trans
330  INTEGER info, ldu1, ldu2, ldv1t, ldv2t, ldx11, ldx12,
331  \$ ldx21, ldx22, lrwork, lwork, m, p, q
332 * ..
333 * .. Array Arguments ..
334  INTEGER iwork( * )
335  DOUBLE PRECISION theta( * )
336  DOUBLE PRECISION rwork( * )
337  COMPLEX*16 u1( ldu1, * ), u2( ldu2, * ), v1t( ldv1t, * ),
338  \$ v2t( ldv2t, * ), work( * ), x11( ldx11, * ),
339  \$ x12( ldx12, * ), x21( ldx21, * ), x22( ldx22,
340  \$ * )
341 * ..
342 *
343 * ===================================================================
344 *
345 * .. Parameters ..
346  COMPLEX*16 one, zero
347  parameter ( one = (1.0d0,0.0d0),
348  \$ zero = (0.0d0,0.0d0) )
349 * ..
350 * .. Local Scalars ..
351  CHARACTER transt, signst
352  INTEGER childinfo, i, ib11d, ib11e, ib12d, ib12e,
353  \$ ib21d, ib21e, ib22d, ib22e, ibbcsd, iorbdb,
354  \$ iorglq, iorgqr, iphi, itaup1, itaup2, itauq1,
355  \$ itauq2, j, lbbcsdwork, lbbcsdworkmin,
356  \$ lbbcsdworkopt, lorbdbwork, lorbdbworkmin,
357  \$ lorbdbworkopt, lorglqwork, lorglqworkmin,
358  \$ lorglqworkopt, lorgqrwork, lorgqrworkmin,
359  \$ lorgqrworkopt, lworkmin, lworkopt, p1, q1
360  LOGICAL colmajor, defaultsigns, lquery, wantu1, wantu2,
361  \$ wantv1t, wantv2t
362  INTEGER lrworkmin, lrworkopt
363  LOGICAL lrquery
364 * ..
365 * .. External Subroutines ..
366  EXTERNAL xerbla, zbbcsd, zlacpy, zlapmr, zlapmt, zlascl,
368 * ..
369 * .. External Functions ..
370  LOGICAL lsame
371  EXTERNAL lsame
372 * ..
373 * .. Intrinsic Functions
374  INTRINSIC int, max, min
375 * ..
376 * .. Executable Statements ..
377 *
378 * Test input arguments
379 *
380  info = 0
381  wantu1 = lsame( jobu1, 'Y' )
382  wantu2 = lsame( jobu2, 'Y' )
383  wantv1t = lsame( jobv1t, 'Y' )
384  wantv2t = lsame( jobv2t, 'Y' )
385  colmajor = .NOT. lsame( trans, 'T' )
386  defaultsigns = .NOT. lsame( signs, 'O' )
387  lquery = lwork .EQ. -1
388  lrquery = lrwork .EQ. -1
389  IF( m .LT. 0 ) THEN
390  info = -7
391  ELSE IF( p .LT. 0 .OR. p .GT. m ) THEN
392  info = -8
393  ELSE IF( q .LT. 0 .OR. q .GT. m ) THEN
394  info = -9
395  ELSE IF ( colmajor .AND. ldx11 .LT. max( 1, p ) ) THEN
396  info = -11
397  ELSE IF (.NOT. colmajor .AND. ldx11 .LT. max( 1, q ) ) THEN
398  info = -11
399  ELSE IF (colmajor .AND. ldx12 .LT. max( 1, p ) ) THEN
400  info = -13
401  ELSE IF (.NOT. colmajor .AND. ldx12 .LT. max( 1, m-q ) ) THEN
402  info = -13
403  ELSE IF (colmajor .AND. ldx21 .LT. max( 1, m-p ) ) THEN
404  info = -15
405  ELSE IF (.NOT. colmajor .AND. ldx21 .LT. max( 1, q ) ) THEN
406  info = -15
407  ELSE IF (colmajor .AND. ldx22 .LT. max( 1, m-p ) ) THEN
408  info = -17
409  ELSE IF (.NOT. colmajor .AND. ldx22 .LT. max( 1, m-q ) ) THEN
410  info = -17
411  ELSE IF( wantu1 .AND. ldu1 .LT. p ) THEN
412  info = -20
413  ELSE IF( wantu2 .AND. ldu2 .LT. m-p ) THEN
414  info = -22
415  ELSE IF( wantv1t .AND. ldv1t .LT. q ) THEN
416  info = -24
417  ELSE IF( wantv2t .AND. ldv2t .LT. m-q ) THEN
418  info = -26
419  END IF
420 *
421 * Work with transpose if convenient
422 *
423  IF( info .EQ. 0 .AND. min( p, m-p ) .LT. min( q, m-q ) ) THEN
424  IF( colmajor ) THEN
425  transt = 'T'
426  ELSE
427  transt = 'N'
428  END IF
429  IF( defaultsigns ) THEN
430  signst = 'O'
431  ELSE
432  signst = 'D'
433  END IF
434  CALL zuncsd( jobv1t, jobv2t, jobu1, jobu2, transt, signst, m,
435  \$ q, p, x11, ldx11, x21, ldx21, x12, ldx12, x22,
436  \$ ldx22, theta, v1t, ldv1t, v2t, ldv2t, u1, ldu1,
437  \$ u2, ldu2, work, lwork, rwork, lrwork, iwork,
438  \$ info )
439  RETURN
440  END IF
441 *
442 * Work with permutation [ 0 I; I 0 ] * X * [ 0 I; I 0 ] if
443 * convenient
444 *
445  IF( info .EQ. 0 .AND. m-q .LT. q ) THEN
446  IF( defaultsigns ) THEN
447  signst = 'O'
448  ELSE
449  signst = 'D'
450  END IF
451  CALL zuncsd( jobu2, jobu1, jobv2t, jobv1t, trans, signst, m,
452  \$ m-p, m-q, x22, ldx22, x21, ldx21, x12, ldx12, x11,
453  \$ ldx11, theta, u2, ldu2, u1, ldu1, v2t, ldv2t, v1t,
454  \$ ldv1t, work, lwork, rwork, lrwork, iwork, info )
455  RETURN
456  END IF
457 *
458 * Compute workspace
459 *
460  IF( info .EQ. 0 ) THEN
461 *
462 * Real workspace
463 *
464  iphi = 2
465  ib11d = iphi + max( 1, q - 1 )
466  ib11e = ib11d + max( 1, q )
467  ib12d = ib11e + max( 1, q - 1 )
468  ib12e = ib12d + max( 1, q )
469  ib21d = ib12e + max( 1, q - 1 )
470  ib21e = ib21d + max( 1, q )
471  ib22d = ib21e + max( 1, q - 1 )
472  ib22e = ib22d + max( 1, q )
473  ibbcsd = ib22e + max( 1, q - 1 )
474  CALL zbbcsd( jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q,
475  \$ theta, theta, u1, ldu1, u2, ldu2, v1t, ldv1t,
476  \$ v2t, ldv2t, theta, theta, theta, theta, theta,
477  \$ theta, theta, theta, rwork, -1, childinfo )
478  lbbcsdworkopt = int( rwork(1) )
479  lbbcsdworkmin = lbbcsdworkopt
480  lrworkopt = ibbcsd + lbbcsdworkopt - 1
481  lrworkmin = ibbcsd + lbbcsdworkmin - 1
482  rwork(1) = lrworkopt
483 *
484 * Complex workspace
485 *
486  itaup1 = 2
487  itaup2 = itaup1 + max( 1, p )
488  itauq1 = itaup2 + max( 1, m - p )
489  itauq2 = itauq1 + max( 1, q )
490  iorgqr = itauq2 + max( 1, m - q )
491  CALL zungqr( m-q, m-q, m-q, u1, max(1,m-q), u1, work, -1,
492  \$ childinfo )
493  lorgqrworkopt = int( work(1) )
494  lorgqrworkmin = max( 1, m - q )
495  iorglq = itauq2 + max( 1, m - q )
496  CALL zunglq( m-q, m-q, m-q, u1, max(1,m-q), u1, work, -1,
497  \$ childinfo )
498  lorglqworkopt = int( work(1) )
499  lorglqworkmin = max( 1, m - q )
500  iorbdb = itauq2 + max( 1, m - q )
501  CALL zunbdb( trans, signs, m, p, q, x11, ldx11, x12, ldx12,
502  \$ x21, ldx21, x22, ldx22, theta, theta, u1, u2,
503  \$ v1t, v2t, work, -1, childinfo )
504  lorbdbworkopt = int( work(1) )
505  lorbdbworkmin = lorbdbworkopt
506  lworkopt = max( iorgqr + lorgqrworkopt, iorglq + lorglqworkopt,
507  \$ iorbdb + lorbdbworkopt ) - 1
508  lworkmin = max( iorgqr + lorgqrworkmin, iorglq + lorglqworkmin,
509  \$ iorbdb + lorbdbworkmin ) - 1
510  work(1) = max(lworkopt,lworkmin)
511 *
512  IF( lwork .LT. lworkmin
513  \$ .AND. .NOT. ( lquery .OR. lrquery ) ) THEN
514  info = -22
515  ELSE IF( lrwork .LT. lrworkmin
516  \$ .AND. .NOT. ( lquery .OR. lrquery ) ) THEN
517  info = -24
518  ELSE
519  lorgqrwork = lwork - iorgqr + 1
520  lorglqwork = lwork - iorglq + 1
521  lorbdbwork = lwork - iorbdb + 1
522  lbbcsdwork = lrwork - ibbcsd + 1
523  END IF
524  END IF
525 *
526 * Abort if any illegal arguments
527 *
528  IF( info .NE. 0 ) THEN
529  CALL xerbla( 'ZUNCSD', -info )
530  RETURN
531  ELSE IF( lquery .OR. lrquery ) THEN
532  RETURN
533  END IF
534 *
535 * Transform to bidiagonal block form
536 *
537  CALL zunbdb( trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21,
538  \$ ldx21, x22, ldx22, theta, rwork(iphi), work(itaup1),
539  \$ work(itaup2), work(itauq1), work(itauq2),
540  \$ work(iorbdb), lorbdbwork, childinfo )
541 *
542 * Accumulate Householder reflectors
543 *
544  IF( colmajor ) THEN
545  IF( wantu1 .AND. p .GT. 0 ) THEN
546  CALL zlacpy( 'L', p, q, x11, ldx11, u1, ldu1 )
547  CALL zungqr( p, p, q, u1, ldu1, work(itaup1), work(iorgqr),
548  \$ lorgqrwork, info)
549  END IF
550  IF( wantu2 .AND. m-p .GT. 0 ) THEN
551  CALL zlacpy( 'L', m-p, q, x21, ldx21, u2, ldu2 )
552  CALL zungqr( m-p, m-p, q, u2, ldu2, work(itaup2),
553  \$ work(iorgqr), lorgqrwork, info )
554  END IF
555  IF( wantv1t .AND. q .GT. 0 ) THEN
556  CALL zlacpy( 'U', q-1, q-1, x11(1,2), ldx11, v1t(2,2),
557  \$ ldv1t )
558  v1t(1, 1) = one
559  DO j = 2, q
560  v1t(1,j) = zero
561  v1t(j,1) = zero
562  END DO
563  CALL zunglq( q-1, q-1, q-1, v1t(2,2), ldv1t, work(itauq1),
564  \$ work(iorglq), lorglqwork, info )
565  END IF
566  IF( wantv2t .AND. m-q .GT. 0 ) THEN
567  CALL zlacpy( 'U', p, m-q, x12, ldx12, v2t, ldv2t )
568  IF( m-p .GT. q) THEN
569  CALL zlacpy( 'U', m-p-q, m-p-q, x22(q+1,p+1), ldx22,
570  \$ v2t(p+1,p+1), ldv2t )
571  END IF
572  IF( m .GT. q ) THEN
573  CALL zunglq( m-q, m-q, m-q, v2t, ldv2t, work(itauq2),
574  \$ work(iorglq), lorglqwork, info )
575  END IF
576  END IF
577  ELSE
578  IF( wantu1 .AND. p .GT. 0 ) THEN
579  CALL zlacpy( 'U', q, p, x11, ldx11, u1, ldu1 )
580  CALL zunglq( p, p, q, u1, ldu1, work(itaup1), work(iorglq),
581  \$ lorglqwork, info)
582  END IF
583  IF( wantu2 .AND. m-p .GT. 0 ) THEN
584  CALL zlacpy( 'U', q, m-p, x21, ldx21, u2, ldu2 )
585  CALL zunglq( m-p, m-p, q, u2, ldu2, work(itaup2),
586  \$ work(iorglq), lorglqwork, info )
587  END IF
588  IF( wantv1t .AND. q .GT. 0 ) THEN
589  CALL zlacpy( 'L', q-1, q-1, x11(2,1), ldx11, v1t(2,2),
590  \$ ldv1t )
591  v1t(1, 1) = one
592  DO j = 2, q
593  v1t(1,j) = zero
594  v1t(j,1) = zero
595  END DO
596  CALL zungqr( q-1, q-1, q-1, v1t(2,2), ldv1t, work(itauq1),
597  \$ work(iorgqr), lorgqrwork, info )
598  END IF
599  IF( wantv2t .AND. m-q .GT. 0 ) THEN
600  p1 = min( p+1, m )
601  q1 = min( q+1, m )
602  CALL zlacpy( 'L', m-q, p, x12, ldx12, v2t, ldv2t )
603  IF( m .GT. p+q ) THEN
604  CALL zlacpy( 'L', m-p-q, m-p-q, x22(p1,q1), ldx22,
605  \$ v2t(p+1,p+1), ldv2t )
606  END IF
607  CALL zungqr( m-q, m-q, m-q, v2t, ldv2t, work(itauq2),
608  \$ work(iorgqr), lorgqrwork, info )
609  END IF
610  END IF
611 *
612 * Compute the CSD of the matrix in bidiagonal-block form
613 *
614  CALL zbbcsd( jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta,
615  \$ rwork(iphi), u1, ldu1, u2, ldu2, v1t, ldv1t, v2t,
616  \$ ldv2t, rwork(ib11d), rwork(ib11e), rwork(ib12d),
617  \$ rwork(ib12e), rwork(ib21d), rwork(ib21e),
618  \$ rwork(ib22d), rwork(ib22e), rwork(ibbcsd),
619  \$ lbbcsdwork, info )
620 *
621 * Permute rows and columns to place identity submatrices in top-
622 * left corner of (1,1)-block and/or bottom-right corner of (1,2)-
623 * block and/or bottom-right corner of (2,1)-block and/or top-left
624 * corner of (2,2)-block
625 *
626  IF( q .GT. 0 .AND. wantu2 ) THEN
627  DO i = 1, q
628  iwork(i) = m - p - q + i
629  END DO
630  DO i = q + 1, m - p
631  iwork(i) = i - q
632  END DO
633  IF( colmajor ) THEN
634  CALL zlapmt( .false., m-p, m-p, u2, ldu2, iwork )
635  ELSE
636  CALL zlapmr( .false., m-p, m-p, u2, ldu2, iwork )
637  END IF
638  END IF
639  IF( m .GT. 0 .AND. wantv2t ) THEN
640  DO i = 1, p
641  iwork(i) = m - p - q + i
642  END DO
643  DO i = p + 1, m - q
644  iwork(i) = i - p
645  END DO
646  IF( .NOT. colmajor ) THEN
647  CALL zlapmt( .false., m-q, m-q, v2t, ldv2t, iwork )
648  ELSE
649  CALL zlapmr( .false., m-q, m-q, v2t, ldv2t, iwork )
650  END IF
651  END IF
652 *
653  RETURN
654 *
655 * End ZUNCSD
656 *
subroutine zunglq(M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
ZUNGLQ
Definition: zunglq.f:129
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:105
subroutine zlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
ZLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values...
Definition: zlaset.f:108
subroutine zlapmt(FORWRD, M, N, X, LDX, K)
ZLAPMT performs a forward or backward permutation of the columns of a matrix.
Definition: zlapmt.f:106
recursive subroutine zuncsd(JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, SIGNS, M, P, Q, X11, LDX11, X12, LDX12, X21, LDX21, X22, LDX22, THETA, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, WORK, LWORK, RWORK, LRWORK, IWORK, INFO)
ZUNCSD
Definition: zuncsd.f:322
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine zunbdb(TRANS, SIGNS, M, P, Q, X11, LDX11, X12, LDX12, X21, LDX21, X22, LDX22, THETA, PHI, TAUP1, TAUP2, TAUQ1, TAUQ2, WORK, LWORK, INFO)
ZUNBDB
Definition: zunbdb.f:289
subroutine zungqr(M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
ZUNGQR
Definition: zungqr.f:130
subroutine zlapmr(FORWRD, M, N, X, LDX, K)
ZLAPMR rearranges rows of a matrix as specified by a permutation vector.
Definition: zlapmr.f:106
subroutine zbbcsd(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)
ZBBCSD
Definition: zbbcsd.f:334
subroutine zlascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
ZLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: zlascl.f:145
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55

Here is the call graph for this function:

Here is the caller graph for this function: