subroutine slasq1	(	integer	N,
		real, dimension( * )	D,
		real, dimension( * )	E,
		real, dimension( * )	WORK,
		integer	INFO
	)

SLASQ1 computes the singular values of a real square bidiagonal matrix. Used by sbdsqr.

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

Purpose:

 SLASQ1 computes the singular values of a real N-by-N bidiagonal
 matrix with diagonal D and off-diagonal E. The singular values
 are computed to high relative accuracy, in the absence of
 denormalization, underflow and overflow. The algorithm was first
 presented in

 "Accurate singular values and differential qd algorithms" by K. V.
 Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230,
 1994,

 and the present implementation is described in "An implementation of
 the dqds Algorithm (Positive Case)", LAPACK Working Note.

Parameters

[in]	N	N is INTEGER The number of rows and columns in the matrix. N >= 0.
[in,out]	D	D is REAL array, dimension (N) On entry, D contains the diagonal elements of the bidiagonal matrix whose SVD is desired. On normal exit, D contains the singular values in decreasing order.
[in,out]	E	E is REAL array, dimension (N) On entry, elements E(1:N-1) contain the off-diagonal elements of the bidiagonal matrix whose SVD is desired. On exit, E is overwritten.
[out]	WORK	WORK is REAL array, dimension (4*N)
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: the algorithm failed = 1, a split was marked by a positive value in E = 2, current block of Z not diagonalized after 100*N iterations (in inner while loop) On exit D and E represent a matrix with the same singular values which the calling subroutine could use to finish the computation, or even feed back into SLASQ1 = 3, termination criterion of outer while loop not met (program created more than N unreduced blocks)

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

November 2015

Definition at line 110 of file slasq1.f.

*
*  -- LAPACK computational routine (version 3.6.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2015
*
*     .. Scalar Arguments ..
      INTEGER            info, n
*     ..
*     .. Array Arguments ..
      REAL               d( * ), e( * ), work( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               zero
      parameter                ( zero = 0.0e0 )
*     ..
*     .. Local Scalars ..
      INTEGER            i, iinfo
      REAL               eps, scale, safmin, sigmn, sigmx
*     ..
*     .. External Subroutines ..
      EXTERNAL           scopy, slas2, slascl, slasq2, slasrt, xerbla
*     ..
*     .. External Functions ..
      REAL               slamch
      EXTERNAL           slamch
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max, sqrt
*     ..
*     .. Executable Statements ..
*
      info = 0
      IF( n.LT.0 ) THEN
         info = -1
         CALL xerbla( 'SLASQ1', -info )
         RETURN
      ELSE IF( n.EQ.0 ) THEN
         RETURN
      ELSE IF( n.EQ.1 ) THEN
         d( 1 ) = abs( d( 1 ) )
         RETURN
      ELSE IF( n.EQ.2 ) THEN
         CALL slas2( d( 1 ), e( 1 ), d( 2 ), sigmn, sigmx )
         d( 1 ) = sigmx
         d( 2 ) = sigmn
         RETURN
      END IF
*
*     Estimate the largest singular value.
*
      sigmx = zero
      DO 10 i = 1, n - 1
         d( i ) = abs( d( i ) )
         sigmx = max( sigmx, abs( e( i ) ) )
   10 CONTINUE
      d( n ) = abs( d( n ) )
*
*     Early return if SIGMX is zero (matrix is already diagonal).
*
      IF( sigmx.EQ.zero ) THEN
         CALL slasrt( 'D', n, d, iinfo )
         RETURN
      END IF
*
      DO 20 i = 1, n
         sigmx = max( sigmx, d( i ) )
   20 CONTINUE
*
*     Copy D and E into WORK (in the Z format) and scale (squaring the
*     input data makes scaling by a power of the radix pointless).
*
      eps = slamch( 'Precision' )
      safmin = slamch( 'Safe minimum' )
      scale = sqrt( eps / safmin )
      CALL scopy( n, d, 1, work( 1 ), 2 )
      CALL scopy( n-1, e, 1, work( 2 ), 2 )
      CALL slascl( 'G', 0, 0, sigmx, scale, 2*n-1, 1, work, 2*n-1,
     $             iinfo )
*         
*     Compute the q's and e's.
*
      DO 30 i = 1, 2*n - 1
         work( i ) = work( i )**2
   30 CONTINUE
      work( 2*n ) = zero
*
      CALL slasq2( n, work, info )
*
      IF( info.EQ.0 ) THEN
         DO 40 i = 1, n
            d( i ) = sqrt( work( i ) )
   40    CONTINUE
         CALL slascl( 'G', 0, 0, scale, sigmx, n, 1, d, n, iinfo )
      ELSE IF( info.EQ.2 ) THEN
*
*     Maximum number of iterations exceeded.  Move data from WORK
*     into D and E so the calling subroutine can try to finish
*
         DO i = 1, n
            d( i ) = sqrt( work( 2*i-1 ) )
            e( i ) = sqrt( work( 2*i ) )
         END DO
         CALL slascl( 'G', 0, 0, scale, sigmx, n, 1, d, n, iinfo )
         CALL slascl( 'G', 0, 0, scale, sigmx, n, 1, e, n, iinfo )
      END IF
*
      RETURN
*
*     End of SLASQ1
*

Here is the call graph for this function:

Here is the caller graph for this function: