LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
zcsdts.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine zcsdts (M, P, Q, X, XF, LDX, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, THETA, IWORK, WORK, LWORK, RWORK, RESULT)
 ZCSDTS More...
 

Function/Subroutine Documentation

subroutine zcsdts ( integer  M,
integer  P,
integer  Q,
complex*16, dimension( ldx, * )  X,
complex*16, dimension( ldx, * )  XF,
integer  LDX,
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,
double precision, dimension( * )  THETA,
integer, dimension( * )  IWORK,
complex*16, dimension( lwork )  WORK,
integer  LWORK,
double precision, dimension( * )  RWORK,
double precision, dimension( 15 )  RESULT 
)

ZCSDTS

Purpose:
 ZCSDTS tests ZUNCSD, which, given an M-by-M partitioned unitary
 matrix X,
              Q  M-Q
       X = [ X11 X12 ] P   ,
           [ X21 X22 ] M-P

 computes the CSD

       [ U1    ]**T * [ X11 X12 ] * [ V1    ]
       [    U2 ]      [ X21 X22 ]   [    V2 ]

                             [  I  0  0 |  0  0  0 ]
                             [  0  C  0 |  0 -S  0 ]
                             [  0  0  0 |  0  0 -I ]
                           = [---------------------] = [ D11 D12 ] .
                             [  0  0  0 |  I  0  0 ]   [ D21 D22 ]
                             [  0  S  0 |  0  C  0 ]
                             [  0  0  I |  0  0  0 ]

 and also SORCSD2BY1, which, given
          Q
       [ X11 ] P   ,
       [ X21 ] M-P

 computes the 2-by-1 CSD

                                     [  I  0  0 ]
                                     [  0  C  0 ]
                                     [  0  0  0 ]
       [ U1    ]**T * [ X11 ] * V1 = [----------] = [ D11 ] ,
       [    U2 ]      [ X21 ]        [  0  0  0 ]   [ D21 ]
                                     [  0  S  0 ]
                                     [  0  0  I ]
Parameters
[in]M
          M is INTEGER
          The number of rows of the matrix X.  M >= 0.
[in]P
          P is INTEGER
          The number of rows of the matrix X11.  P >= 0.
[in]Q
          Q is INTEGER
          The number of columns of the matrix X11.  Q >= 0.
[in]X
          X is COMPLEX*16 array, dimension (LDX,M)
          The M-by-M matrix X.
[out]XF
          XF is COMPLEX*16 array, dimension (LDX,M)
          Details of the CSD of X, as returned by ZUNCSD;
          see ZUNCSD for further details.
[in]LDX
          LDX is INTEGER
          The leading dimension of the arrays X and XF.
          LDX >= max( 1,M ).
[out]U1
          U1 is COMPLEX*16 array, dimension(LDU1,P)
          The P-by-P unitary matrix U1.
[in]LDU1
          LDU1 is INTEGER
          The leading dimension of the array U1. LDU >= max(1,P).
[out]U2
          U2 is COMPLEX*16 array, dimension(LDU2,M-P)
          The (M-P)-by-(M-P) unitary matrix U2.
[in]LDU2
          LDU2 is INTEGER
          The leading dimension of the array U2. LDU >= max(1,M-P).
[out]V1T
          V1T is COMPLEX*16 array, dimension(LDV1T,Q)
          The Q-by-Q unitary matrix V1T.
[in]LDV1T
          LDV1T is INTEGER
          The leading dimension of the array V1T. LDV1T >=
          max(1,Q).
[out]V2T
          V2T is COMPLEX*16 array, dimension(LDV2T,M-Q)
          The (M-Q)-by-(M-Q) unitary matrix V2T.
[in]LDV2T
          LDV2T is INTEGER
          The leading dimension of the array V2T. LDV2T >=
          max(1,M-Q).
[out]THETA
          THETA is DOUBLE PRECISION array, dimension MIN(P,M-P,Q,M-Q)
          The CS values of X; the essentially diagonal matrices C and
          S are constructed from THETA; see subroutine ZUNCSD for
          details.
[out]IWORK
          IWORK is INTEGER array, dimension (M)
[out]WORK
          WORK is COMPLEX*16 array, dimension (LWORK)
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK
[out]RWORK
          RWORK is DOUBLE PRECISION array
[out]RESULT
          RESULT is DOUBLE PRECISION array, dimension (15)
          The test ratios:
          First, the 2-by-2 CSD:
          RESULT(1) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
          RESULT(2) = norm( U1'*X12*V2 - D12 ) / ( MAX(1,P,M-Q)*EPS2 )
          RESULT(3) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
          RESULT(4) = norm( U2'*X22*V2 - D22 ) / ( MAX(1,M-P,M-Q)*EPS2 )
          RESULT(5) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
          RESULT(6) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*ULP )
          RESULT(7) = norm( I - V1T'*V1T ) / ( MAX(1,Q)*ULP )
          RESULT(8) = norm( I - V2T'*V2T ) / ( MAX(1,M-Q)*ULP )
          RESULT(9) = 0        if THETA is in increasing order and
                               all angles are in [0,pi/2];
                    = ULPINV   otherwise.
          Then, the 2-by-1 CSD:
          RESULT(10) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
          RESULT(11) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
          RESULT(12) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
          RESULT(13) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*ULP )
          RESULT(14) = norm( I - V1T'*V1T ) / ( MAX(1,Q)*ULP )
          RESULT(15) = 0        if THETA is in increasing order and
                                all angles are in [0,pi/2];
                     = ULPINV   otherwise.
          ( EPS2 = MAX( norm( I - X'*X ) / M, ULP ). )
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 231 of file zcsdts.f.

231 *
232 * -- LAPACK test routine (version 3.4.0) --
233 * -- LAPACK is a software package provided by Univ. of Tennessee, --
234 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
235 * November 2011
236 *
237 * .. Scalar Arguments ..
238  INTEGER ldx, ldu1, ldu2, ldv1t, ldv2t, lwork, m, p, q
239 * ..
240 * .. Array Arguments ..
241  INTEGER iwork( * )
242  DOUBLE PRECISION result( 15 ), rwork( * ), theta( * )
243  COMPLEX*16 u1( ldu1, * ), u2( ldu2, * ), v1t( ldv1t, * ),
244  $ v2t( ldv2t, * ), work( lwork ), x( ldx, * ),
245  $ xf( ldx, * )
246 * ..
247 *
248 * =====================================================================
249 *
250 * .. Parameters ..
251  DOUBLE PRECISION piover2, realone, realzero
252  parameter( piover2 = 1.57079632679489662d0,
253  $ realone = 1.0d0, realzero = 0.0d0 )
254  COMPLEX*16 zero, one
255  parameter( zero = (0.0d0,0.0d0), one = (1.0d0,0.0d0) )
256 * ..
257 * .. Local Scalars ..
258  INTEGER i, info, r
259  DOUBLE PRECISION eps2, resid, ulp, ulpinv
260 * ..
261 * .. External Functions ..
262  DOUBLE PRECISION dlamch, zlange, zlanhe
263  EXTERNAL dlamch, zlange, zlanhe
264 * ..
265 * .. External Subroutines ..
266  EXTERNAL zgemm, zherk, zlacpy, zlaset, zuncsd, zuncsd2by1
267 * ..
268 * .. Intrinsic Functions ..
269  INTRINSIC cos, dble, dcmplx, max, min, REAL, sin
270 * ..
271 * .. Executable Statements ..
272 *
273  ulp = dlamch( 'Precision' )
274  ulpinv = realone / ulp
275 *
276 * The first half of the routine checks the 2-by-2 CSD
277 *
278  CALL zlaset( 'Full', m, m, zero, one, work, ldx )
279  CALL zherk( 'Upper', 'Conjugate transpose', m, m, -realone,
280  $ x, ldx, realone, work, ldx )
281  IF (m.GT.0) THEN
282  eps2 = max( ulp,
283  $ zlange( '1', m, m, work, ldx, rwork ) / dble( m ) )
284  ELSE
285  eps2 = ulp
286  END IF
287  r = min( p, m-p, q, m-q )
288 *
289 * Copy the matrix X to the array XF.
290 *
291  CALL zlacpy( 'Full', m, m, x, ldx, xf, ldx )
292 *
293 * Compute the CSD
294 *
295  CALL zuncsd( 'Y', 'Y', 'Y', 'Y', 'N', 'D', m, p, q, xf(1,1), ldx,
296  $ xf(1,q+1), ldx, xf(p+1,1), ldx, xf(p+1,q+1), ldx,
297  $ theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t,
298  $ work, lwork, rwork, 17*(r+2), iwork, info )
299 *
300 * Compute XF := diag(U1,U2)'*X*diag(V1,V2) - [D11 D12; D21 D22]
301 *
302  CALL zlacpy( 'Full', m, m, x, ldx, xf, ldx )
303 *
304  CALL zgemm( 'No transpose', 'Conjugate transpose', p, q, q, one,
305  $ xf, ldx, v1t, ldv1t, zero, work, ldx )
306 *
307  CALL zgemm( 'Conjugate transpose', 'No transpose', p, q, p, one,
308  $ u1, ldu1, work, ldx, zero, xf, ldx )
309 *
310  DO i = 1, min(p,q)-r
311  xf(i,i) = xf(i,i) - one
312  END DO
313  DO i = 1, r
314  xf(min(p,q)-r+i,min(p,q)-r+i) =
315  $ xf(min(p,q)-r+i,min(p,q)-r+i) - dcmplx( cos(theta(i)),
316  $ 0.0d0 )
317  END DO
318 *
319  CALL zgemm( 'No transpose', 'Conjugate transpose', p, m-q, m-q,
320  $ one, xf(1,q+1), ldx, v2t, ldv2t, zero, work, ldx )
321 *
322  CALL zgemm( 'Conjugate transpose', 'No transpose', p, m-q, p,
323  $ one, u1, ldu1, work, ldx, zero, xf(1,q+1), ldx )
324 *
325  DO i = 1, min(p,m-q)-r
326  xf(p-i+1,m-i+1) = xf(p-i+1,m-i+1) + one
327  END DO
328  DO i = 1, r
329  xf(p-(min(p,m-q)-r)+1-i,m-(min(p,m-q)-r)+1-i) =
330  $ xf(p-(min(p,m-q)-r)+1-i,m-(min(p,m-q)-r)+1-i) +
331  $ dcmplx( sin(theta(r-i+1)), 0.0d0 )
332  END DO
333 *
334  CALL zgemm( 'No transpose', 'Conjugate transpose', m-p, q, q, one,
335  $ xf(p+1,1), ldx, v1t, ldv1t, zero, work, ldx )
336 *
337  CALL zgemm( 'Conjugate transpose', 'No transpose', m-p, q, m-p,
338  $ one, u2, ldu2, work, ldx, zero, xf(p+1,1), ldx )
339 *
340  DO i = 1, min(m-p,q)-r
341  xf(m-i+1,q-i+1) = xf(m-i+1,q-i+1) - one
342  END DO
343  DO i = 1, r
344  xf(m-(min(m-p,q)-r)+1-i,q-(min(m-p,q)-r)+1-i) =
345  $ xf(m-(min(m-p,q)-r)+1-i,q-(min(m-p,q)-r)+1-i) -
346  $ dcmplx( sin(theta(r-i+1)), 0.0d0 )
347  END DO
348 *
349  CALL zgemm( 'No transpose', 'Conjugate transpose', m-p, m-q, m-q,
350  $ one, xf(p+1,q+1), ldx, v2t, ldv2t, zero, work, ldx )
351 *
352  CALL zgemm( 'Conjugate transpose', 'No transpose', m-p, m-q, m-p,
353  $ one, u2, ldu2, work, ldx, zero, xf(p+1,q+1), ldx )
354 *
355  DO i = 1, min(m-p,m-q)-r
356  xf(p+i,q+i) = xf(p+i,q+i) - one
357  END DO
358  DO i = 1, r
359  xf(p+(min(m-p,m-q)-r)+i,q+(min(m-p,m-q)-r)+i) =
360  $ xf(p+(min(m-p,m-q)-r)+i,q+(min(m-p,m-q)-r)+i) -
361  $ dcmplx( cos(theta(i)), 0.0d0 )
362  END DO
363 *
364 * Compute norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 ) .
365 *
366  resid = zlange( '1', p, q, xf, ldx, rwork )
367  result( 1 ) = ( resid / REAL(MAX(1,P,Q)) ) / eps2
368 *
369 * Compute norm( U1'*X12*V2 - D12 ) / ( MAX(1,P,M-Q)*EPS2 ) .
370 *
371  resid = zlange( '1', p, m-q, xf(1,q+1), ldx, rwork )
372  result( 2 ) = ( resid / REAL(MAX(1,P,M-Q)) ) / eps2
373 *
374 * Compute norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 ) .
375 *
376  resid = zlange( '1', m-p, q, xf(p+1,1), ldx, rwork )
377  result( 3 ) = ( resid / REAL(MAX(1,M-P,Q)) ) / eps2
378 *
379 * Compute norm( U2'*X22*V2 - D22 ) / ( MAX(1,M-P,M-Q)*EPS2 ) .
380 *
381  resid = zlange( '1', m-p, m-q, xf(p+1,q+1), ldx, rwork )
382  result( 4 ) = ( resid / REAL(MAX(1,M-P,M-Q)) ) / eps2
383 *
384 * Compute I - U1'*U1
385 *
386  CALL zlaset( 'Full', p, p, zero, one, work, ldu1 )
387  CALL zherk( 'Upper', 'Conjugate transpose', p, p, -realone,
388  $ u1, ldu1, realone, work, ldu1 )
389 *
390 * Compute norm( I - U'*U ) / ( MAX(1,P) * ULP ) .
391 *
392  resid = zlanhe( '1', 'Upper', p, work, ldu1, rwork )
393  result( 5 ) = ( resid / REAL(MAX(1,P)) ) / ulp
394 *
395 * Compute I - U2'*U2
396 *
397  CALL zlaset( 'Full', m-p, m-p, zero, one, work, ldu2 )
398  CALL zherk( 'Upper', 'Conjugate transpose', m-p, m-p, -realone,
399  $ u2, ldu2, realone, work, ldu2 )
400 *
401 * Compute norm( I - U2'*U2 ) / ( MAX(1,M-P) * ULP ) .
402 *
403  resid = zlanhe( '1', 'Upper', m-p, work, ldu2, rwork )
404  result( 6 ) = ( resid / REAL(MAX(1,M-P)) ) / ulp
405 *
406 * Compute I - V1T*V1T'
407 *
408  CALL zlaset( 'Full', q, q, zero, one, work, ldv1t )
409  CALL zherk( 'Upper', 'No transpose', q, q, -realone,
410  $ v1t, ldv1t, realone, work, ldv1t )
411 *
412 * Compute norm( I - V1T*V1T' ) / ( MAX(1,Q) * ULP ) .
413 *
414  resid = zlanhe( '1', 'Upper', q, work, ldv1t, rwork )
415  result( 7 ) = ( resid / REAL(MAX(1,Q)) ) / ulp
416 *
417 * Compute I - V2T*V2T'
418 *
419  CALL zlaset( 'Full', m-q, m-q, zero, one, work, ldv2t )
420  CALL zherk( 'Upper', 'No transpose', m-q, m-q, -realone,
421  $ v2t, ldv2t, realone, work, ldv2t )
422 *
423 * Compute norm( I - V2T*V2T' ) / ( MAX(1,M-Q) * ULP ) .
424 *
425  resid = zlanhe( '1', 'Upper', m-q, work, ldv2t, rwork )
426  result( 8 ) = ( resid / REAL(MAX(1,M-Q)) ) / ulp
427 *
428 * Check sorting
429 *
430  result( 9 ) = realzero
431  DO i = 1, r
432  IF( theta(i).LT.realzero .OR. theta(i).GT.piover2 ) THEN
433  result( 9 ) = ulpinv
434  END IF
435  IF( i.GT.1) THEN
436  IF ( theta(i).LT.theta(i-1) ) THEN
437  result( 9 ) = ulpinv
438  END IF
439  END IF
440  END DO
441 *
442 * The second half of the routine checks the 2-by-1 CSD
443 *
444  CALL zlaset( 'Full', q, q, zero, one, work, ldx )
445  CALL zherk( 'Upper', 'Conjugate transpose', q, m, -realone,
446  $ x, ldx, realone, work, ldx )
447  IF (m.GT.0) THEN
448  eps2 = max( ulp,
449  $ zlange( '1', q, q, work, ldx, rwork ) / dble( m ) )
450  ELSE
451  eps2 = ulp
452  END IF
453  r = min( p, m-p, q, m-q )
454 *
455 * Copy the matrix X to the array XF.
456 *
457  CALL zlacpy( 'Full', m, m, x, ldx, xf, ldx )
458 *
459 * Compute the CSD
460 *
461  CALL zuncsd2by1( 'Y', 'Y', 'Y', m, p, q, xf(1,1), ldx, xf(p+1,1),
462  $ ldx, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work,
463  $ lwork, rwork, 17*(r+2), iwork, info )
464 *
465 * Compute [X11;X21] := diag(U1,U2)'*[X11;X21]*V1 - [D11;D21]
466 *
467  CALL zgemm( 'No transpose', 'Conjugate transpose', p, q, q, one,
468  $ x, ldx, v1t, ldv1t, zero, work, ldx )
469 *
470  CALL zgemm( 'Conjugate transpose', 'No transpose', p, q, p, one,
471  $ u1, ldu1, work, ldx, zero, x, ldx )
472 *
473  DO i = 1, min(p,q)-r
474  x(i,i) = x(i,i) - one
475  END DO
476  DO i = 1, r
477  x(min(p,q)-r+i,min(p,q)-r+i) =
478  $ x(min(p,q)-r+i,min(p,q)-r+i) - dcmplx( cos(theta(i)),
479  $ 0.0d0 )
480  END DO
481 *
482  CALL zgemm( 'No transpose', 'Conjugate transpose', m-p, q, q, one,
483  $ x(p+1,1), ldx, v1t, ldv1t, zero, work, ldx )
484 *
485  CALL zgemm( 'Conjugate transpose', 'No transpose', m-p, q, m-p,
486  $ one, u2, ldu2, work, ldx, zero, x(p+1,1), ldx )
487 *
488  DO i = 1, min(m-p,q)-r
489  x(m-i+1,q-i+1) = x(m-i+1,q-i+1) - one
490  END DO
491  DO i = 1, r
492  x(m-(min(m-p,q)-r)+1-i,q-(min(m-p,q)-r)+1-i) =
493  $ x(m-(min(m-p,q)-r)+1-i,q-(min(m-p,q)-r)+1-i) -
494  $ dcmplx( sin(theta(r-i+1)), 0.0d0 )
495  END DO
496 *
497 * Compute norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 ) .
498 *
499  resid = zlange( '1', p, q, x, ldx, rwork )
500  result( 10 ) = ( resid / REAL(MAX(1,P,Q)) ) / eps2
501 *
502 * Compute norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 ) .
503 *
504  resid = zlange( '1', m-p, q, x(p+1,1), ldx, rwork )
505  result( 11 ) = ( resid / REAL(MAX(1,M-P,Q)) ) / eps2
506 *
507 * Compute I - U1'*U1
508 *
509  CALL zlaset( 'Full', p, p, zero, one, work, ldu1 )
510  CALL zherk( 'Upper', 'Conjugate transpose', p, p, -realone,
511  $ u1, ldu1, realone, work, ldu1 )
512 *
513 * Compute norm( I - U'*U ) / ( MAX(1,P) * ULP ) .
514 *
515  resid = zlanhe( '1', 'Upper', p, work, ldu1, rwork )
516  result( 12 ) = ( resid / REAL(MAX(1,P)) ) / ulp
517 *
518 * Compute I - U2'*U2
519 *
520  CALL zlaset( 'Full', m-p, m-p, zero, one, work, ldu2 )
521  CALL zherk( 'Upper', 'Conjugate transpose', m-p, m-p, -realone,
522  $ u2, ldu2, realone, work, ldu2 )
523 *
524 * Compute norm( I - U2'*U2 ) / ( MAX(1,M-P) * ULP ) .
525 *
526  resid = zlanhe( '1', 'Upper', m-p, work, ldu2, rwork )
527  result( 13 ) = ( resid / REAL(MAX(1,M-P)) ) / ulp
528 *
529 * Compute I - V1T*V1T'
530 *
531  CALL zlaset( 'Full', q, q, zero, one, work, ldv1t )
532  CALL zherk( 'Upper', 'No transpose', q, q, -realone,
533  $ v1t, ldv1t, realone, work, ldv1t )
534 *
535 * Compute norm( I - V1T*V1T' ) / ( MAX(1,Q) * ULP ) .
536 *
537  resid = zlanhe( '1', 'Upper', q, work, ldv1t, rwork )
538  result( 14 ) = ( resid / REAL(MAX(1,Q)) ) / ulp
539 *
540 * Check sorting
541 *
542  result( 15 ) = realzero
543  DO i = 1, r
544  IF( theta(i).LT.realzero .OR. theta(i).GT.piover2 ) THEN
545  result( 15 ) = ulpinv
546  END IF
547  IF( i.GT.1) THEN
548  IF ( theta(i).LT.theta(i-1) ) THEN
549  result( 15 ) = ulpinv
550  END IF
551  END IF
552  END DO
553 *
554  RETURN
555 *
556 * End of ZCSDTS
557 *
subroutine zherk(UPLO, TRANS, N, K, ALPHA, A, LDA, BETA, C, LDC)
ZHERK
Definition: zherk.f:175
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
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
double precision function zlanhe(NORM, UPLO, N, A, LDA, WORK)
ZLANHE returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix.
Definition: zlanhe.f:126
subroutine zgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
ZGEMM
Definition: zgemm.f:189
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
double precision function zlange(NORM, M, N, A, LDA, WORK)
ZLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: zlange.f:117
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:65
subroutine zuncsd2by1(JOBU1, JOBU2, JOBV1T, M, P, Q, X11, LDX11, X21, LDX21, THETA, U1, LDU1, U2, LDU2, V1T, LDV1T, WORK, LWORK, RWORK, LRWORK, IWORK, INFO)
ZUNCSD2BY1
Definition: zuncsd2by1.f:263

Here is the call graph for this function:

Here is the caller graph for this function: