LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ cuncsd()

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

CUNCSD

Download CUNCSD + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 CUNCSD 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 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 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 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 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 REAL 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 array, dimension (LDU1,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 array, dimension (LDU2,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 array, dimension (LDV1T,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 array, dimension (LDV2T,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 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 REAL 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:  CBBCSD 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.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 314 of file cuncsd.f.

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