LAPACK  3.10.0
LAPACK: Linear Algebra PACKage
slasd8.f
Go to the documentation of this file.
1 *> \brief \b SLASD8 finds the square roots of the roots of the secular equation, and stores, for each element in D, the distance to its two nearest poles. Used by sbdsdc.
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download SLASD8 + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/slasd8.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/slasd8.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/slasd8.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE SLASD8( ICOMPQ, K, D, Z, VF, VL, DIFL, DIFR, LDDIFR,
22 * DSIGMA, WORK, INFO )
23 *
24 * .. Scalar Arguments ..
25 * INTEGER ICOMPQ, INFO, K, LDDIFR
26 * ..
27 * .. Array Arguments ..
28 * REAL D( * ), DIFL( * ), DIFR( LDDIFR, * ),
29 * $ DSIGMA( * ), VF( * ), VL( * ), WORK( * ),
30 * $ Z( * )
31 * ..
32 *
33 *
34 *> \par Purpose:
35 * =============
36 *>
37 *> \verbatim
38 *>
39 *> SLASD8 finds the square roots of the roots of the secular equation,
40 *> as defined by the values in DSIGMA and Z. It makes the appropriate
41 *> calls to SLASD4, and stores, for each element in D, the distance
42 *> to its two nearest poles (elements in DSIGMA). It also updates
43 *> the arrays VF and VL, the first and last components of all the
44 *> right singular vectors of the original bidiagonal matrix.
45 *>
46 *> SLASD8 is called from SLASD6.
47 *> \endverbatim
48 *
49 * Arguments:
50 * ==========
51 *
52 *> \param[in] ICOMPQ
53 *> \verbatim
54 *> ICOMPQ is INTEGER
55 *> Specifies whether singular vectors are to be computed in
56 *> factored form in the calling routine:
57 *> = 0: Compute singular values only.
58 *> = 1: Compute singular vectors in factored form as well.
59 *> \endverbatim
60 *>
61 *> \param[in] K
62 *> \verbatim
63 *> K is INTEGER
64 *> The number of terms in the rational function to be solved
65 *> by SLASD4. K >= 1.
66 *> \endverbatim
67 *>
68 *> \param[out] D
69 *> \verbatim
70 *> D is REAL array, dimension ( K )
71 *> On output, D contains the updated singular values.
72 *> \endverbatim
73 *>
74 *> \param[in,out] Z
75 *> \verbatim
76 *> Z is REAL array, dimension ( K )
77 *> On entry, the first K elements of this array contain the
78 *> components of the deflation-adjusted updating row vector.
79 *> On exit, Z is updated.
80 *> \endverbatim
81 *>
82 *> \param[in,out] VF
83 *> \verbatim
84 *> VF is REAL array, dimension ( K )
85 *> On entry, VF contains information passed through DBEDE8.
86 *> On exit, VF contains the first K components of the first
87 *> components of all right singular vectors of the bidiagonal
88 *> matrix.
89 *> \endverbatim
90 *>
91 *> \param[in,out] VL
92 *> \verbatim
93 *> VL is REAL array, dimension ( K )
94 *> On entry, VL contains information passed through DBEDE8.
95 *> On exit, VL contains the first K components of the last
96 *> components of all right singular vectors of the bidiagonal
97 *> matrix.
98 *> \endverbatim
99 *>
100 *> \param[out] DIFL
101 *> \verbatim
102 *> DIFL is REAL array, dimension ( K )
103 *> On exit, DIFL(I) = D(I) - DSIGMA(I).
104 *> \endverbatim
105 *>
106 *> \param[out] DIFR
107 *> \verbatim
108 *> DIFR is REAL array,
109 *> dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and
110 *> dimension ( K ) if ICOMPQ = 0.
111 *> On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not
112 *> defined and will not be referenced.
113 *>
114 *> If ICOMPQ = 1, DIFR(1:K,2) is an array containing the
115 *> normalizing factors for the right singular vector matrix.
116 *> \endverbatim
117 *>
118 *> \param[in] LDDIFR
119 *> \verbatim
120 *> LDDIFR is INTEGER
121 *> The leading dimension of DIFR, must be at least K.
122 *> \endverbatim
123 *>
124 *> \param[in,out] DSIGMA
125 *> \verbatim
126 *> DSIGMA is REAL array, dimension ( K )
127 *> On entry, the first K elements of this array contain the old
128 *> roots of the deflated updating problem. These are the poles
129 *> of the secular equation.
130 *> On exit, the elements of DSIGMA may be very slightly altered
131 *> in value.
132 *> \endverbatim
133 *>
134 *> \param[out] WORK
135 *> \verbatim
136 *> WORK is REAL array, dimension (3*K)
137 *> \endverbatim
138 *>
139 *> \param[out] INFO
140 *> \verbatim
141 *> INFO is INTEGER
142 *> = 0: successful exit.
143 *> < 0: if INFO = -i, the i-th argument had an illegal value.
144 *> > 0: if INFO = 1, a singular value did not converge
145 *> \endverbatim
146 *
147 * Authors:
148 * ========
149 *
150 *> \author Univ. of Tennessee
151 *> \author Univ. of California Berkeley
152 *> \author Univ. of Colorado Denver
153 *> \author NAG Ltd.
154 *
155 *> \ingroup OTHERauxiliary
156 *
157 *> \par Contributors:
158 * ==================
159 *>
160 *> Ming Gu and Huan Ren, Computer Science Division, University of
161 *> California at Berkeley, USA
162 *>
163 * =====================================================================
164  SUBROUTINE slasd8( ICOMPQ, K, D, Z, VF, VL, DIFL, DIFR, LDDIFR,
165  $ DSIGMA, WORK, INFO )
166 *
167 * -- LAPACK auxiliary routine --
168 * -- LAPACK is a software package provided by Univ. of Tennessee, --
169 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
170 *
171 * .. Scalar Arguments ..
172  INTEGER ICOMPQ, INFO, K, LDDIFR
173 * ..
174 * .. Array Arguments ..
175  REAL D( * ), DIFL( * ), DIFR( LDDIFR, * ),
176  $ dsigma( * ), vf( * ), vl( * ), work( * ),
177  $ z( * )
178 * ..
179 *
180 * =====================================================================
181 *
182 * .. Parameters ..
183  REAL ONE
184  parameter( one = 1.0e+0 )
185 * ..
186 * .. Local Scalars ..
187  INTEGER I, IWK1, IWK2, IWK2I, IWK3, IWK3I, J
188  REAL DIFLJ, DIFRJ, DJ, DSIGJ, DSIGJP, RHO, TEMP
189 * ..
190 * .. External Subroutines ..
191  EXTERNAL scopy, slascl, slasd4, slaset, xerbla
192 * ..
193 * .. External Functions ..
194  REAL SDOT, SLAMC3, SNRM2
195  EXTERNAL sdot, slamc3, snrm2
196 * ..
197 * .. Intrinsic Functions ..
198  INTRINSIC abs, sign, sqrt
199 * ..
200 * .. Executable Statements ..
201 *
202 * Test the input parameters.
203 *
204  info = 0
205 *
206  IF( ( icompq.LT.0 ) .OR. ( icompq.GT.1 ) ) THEN
207  info = -1
208  ELSE IF( k.LT.1 ) THEN
209  info = -2
210  ELSE IF( lddifr.LT.k ) THEN
211  info = -9
212  END IF
213  IF( info.NE.0 ) THEN
214  CALL xerbla( 'SLASD8', -info )
215  RETURN
216  END IF
217 *
218 * Quick return if possible
219 *
220  IF( k.EQ.1 ) THEN
221  d( 1 ) = abs( z( 1 ) )
222  difl( 1 ) = d( 1 )
223  IF( icompq.EQ.1 ) THEN
224  difl( 2 ) = one
225  difr( 1, 2 ) = one
226  END IF
227  RETURN
228  END IF
229 *
230 * Modify values DSIGMA(i) to make sure all DSIGMA(i)-DSIGMA(j) can
231 * be computed with high relative accuracy (barring over/underflow).
232 * This is a problem on machines without a guard digit in
233 * add/subtract (Cray XMP, Cray YMP, Cray C 90 and Cray 2).
234 * The following code replaces DSIGMA(I) by 2*DSIGMA(I)-DSIGMA(I),
235 * which on any of these machines zeros out the bottommost
236 * bit of DSIGMA(I) if it is 1; this makes the subsequent
237 * subtractions DSIGMA(I)-DSIGMA(J) unproblematic when cancellation
238 * occurs. On binary machines with a guard digit (almost all
239 * machines) it does not change DSIGMA(I) at all. On hexadecimal
240 * and decimal machines with a guard digit, it slightly
241 * changes the bottommost bits of DSIGMA(I). It does not account
242 * for hexadecimal or decimal machines without guard digits
243 * (we know of none). We use a subroutine call to compute
244 * 2*DLAMBDA(I) to prevent optimizing compilers from eliminating
245 * this code.
246 *
247  DO 10 i = 1, k
248  dsigma( i ) = slamc3( dsigma( i ), dsigma( i ) ) - dsigma( i )
249  10 CONTINUE
250 *
251 * Book keeping.
252 *
253  iwk1 = 1
254  iwk2 = iwk1 + k
255  iwk3 = iwk2 + k
256  iwk2i = iwk2 - 1
257  iwk3i = iwk3 - 1
258 *
259 * Normalize Z.
260 *
261  rho = snrm2( k, z, 1 )
262  CALL slascl( 'G', 0, 0, rho, one, k, 1, z, k, info )
263  rho = rho*rho
264 *
265 * Initialize WORK(IWK3).
266 *
267  CALL slaset( 'A', k, 1, one, one, work( iwk3 ), k )
268 *
269 * Compute the updated singular values, the arrays DIFL, DIFR,
270 * and the updated Z.
271 *
272  DO 40 j = 1, k
273  CALL slasd4( k, j, dsigma, z, work( iwk1 ), rho, d( j ),
274  $ work( iwk2 ), info )
275 *
276 * If the root finder fails, report the convergence failure.
277 *
278  IF( info.NE.0 ) THEN
279  RETURN
280  END IF
281  work( iwk3i+j ) = work( iwk3i+j )*work( j )*work( iwk2i+j )
282  difl( j ) = -work( j )
283  difr( j, 1 ) = -work( j+1 )
284  DO 20 i = 1, j - 1
285  work( iwk3i+i ) = work( iwk3i+i )*work( i )*
286  $ work( iwk2i+i ) / ( dsigma( i )-
287  $ dsigma( j ) ) / ( dsigma( i )+
288  $ dsigma( j ) )
289  20 CONTINUE
290  DO 30 i = j + 1, k
291  work( iwk3i+i ) = work( iwk3i+i )*work( i )*
292  $ work( iwk2i+i ) / ( dsigma( i )-
293  $ dsigma( j ) ) / ( dsigma( i )+
294  $ dsigma( j ) )
295  30 CONTINUE
296  40 CONTINUE
297 *
298 * Compute updated Z.
299 *
300  DO 50 i = 1, k
301  z( i ) = sign( sqrt( abs( work( iwk3i+i ) ) ), z( i ) )
302  50 CONTINUE
303 *
304 * Update VF and VL.
305 *
306  DO 80 j = 1, k
307  diflj = difl( j )
308  dj = d( j )
309  dsigj = -dsigma( j )
310  IF( j.LT.k ) THEN
311  difrj = -difr( j, 1 )
312  dsigjp = -dsigma( j+1 )
313  END IF
314  work( j ) = -z( j ) / diflj / ( dsigma( j )+dj )
315  DO 60 i = 1, j - 1
316  work( i ) = z( i ) / ( slamc3( dsigma( i ), dsigj )-diflj )
317  $ / ( dsigma( i )+dj )
318  60 CONTINUE
319  DO 70 i = j + 1, k
320  work( i ) = z( i ) / ( slamc3( dsigma( i ), dsigjp )+difrj )
321  $ / ( dsigma( i )+dj )
322  70 CONTINUE
323  temp = snrm2( k, work, 1 )
324  work( iwk2i+j ) = sdot( k, work, 1, vf, 1 ) / temp
325  work( iwk3i+j ) = sdot( k, work, 1, vl, 1 ) / temp
326  IF( icompq.EQ.1 ) THEN
327  difr( j, 2 ) = temp
328  END IF
329  80 CONTINUE
330 *
331  CALL scopy( k, work( iwk2 ), 1, vf, 1 )
332  CALL scopy( k, work( iwk3 ), 1, vl, 1 )
333 *
334  RETURN
335 *
336 * End of SLASD8
337 *
338  END
339 
subroutine slascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
SLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: slascl.f:143
subroutine slaset(UPLO, M, N, ALPHA, BETA, A, LDA)
SLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: slaset.f:110
subroutine slasd4(N, I, D, Z, DELTA, RHO, SIGMA, WORK, INFO)
SLASD4 computes the square root of the i-th updated eigenvalue of a positive symmetric rank-one modif...
Definition: slasd4.f:153
subroutine slasd8(ICOMPQ, K, D, Z, VF, VL, DIFL, DIFR, LDDIFR, DSIGMA, WORK, INFO)
SLASD8 finds the square roots of the roots of the secular equation, and stores, for each element in D...
Definition: slasd8.f:166
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:82