Debian Codegraph @

Modules/ThirdParty/VNL/src/vxl/v3p/netlib/lapack/double/dtgsyl.f

raw
1 SUBROUTINE DTGSYL( TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D,
2 $ LDD, E, LDE, F, LDF, SCALE, DIF, WORK, LWORK,
3 $ IWORK, INFO )
4 *
5 * -- LAPACK routine (version 3.0) --
6 * Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
7 * Courant Institute, Argonne National Lab, and Rice University
8 * June 30, 1999
9 *
10 * .. Scalar Arguments ..
11 CHARACTER TRANS
12 INTEGER IJOB, INFO, LDA, LDB, LDC, LDD, LDE, LDF,
13 $ LWORK, M, N
14 DOUBLE PRECISION DIF, SCALE
15 * ..
16 * .. Array Arguments ..
17 INTEGER IWORK( * )
18 DOUBLE PRECISION A( LDA, * ), B( LDB, * ), C( LDC, * ),
19 $ D( LDD, * ), E( LDE, * ), F( LDF, * ),
20 $ WORK( * )
21 * ..
22 *
23 * Purpose
24 * =======
25 *
26 * DTGSYL solves the generalized Sylvester equation:
27 *
28 * A * R - L * B = scale * C (1)
29 * D * R - L * E = scale * F
30 *
31 * where R and L are unknown m-by-n matrices, (A, D), (B, E) and
32 * (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n,
33 * respectively, with real entries. (A, D) and (B, E) must be in
34 * generalized (real) Schur canonical form, i.e. A, B are upper quasi
35 * triangular and D, E are upper triangular.
36 *
37 * The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output
38 * scaling factor chosen to avoid overflow.
39 *
40 * In matrix notation (1) is equivalent to solve Zx = scale b, where
41 * Z is defined as
42 *
43 * Z = [ kron(In, A) -kron(B', Im) ] (2)
44 * [ kron(In, D) -kron(E', Im) ].
45 *
46 * Here Ik is the identity matrix of size k and X' is the transpose of
47 * X. kron(X, Y) is the Kronecker product between the matrices X and Y.
48 *
49 * If TRANS = 'T', DTGSYL solves the transposed system Z'*y = scale*b,
50 * which is equivalent to solve for R and L in
51 *
52 * A' * R + D' * L = scale * C (3)
53 * R * B' + L * E' = scale * (-F)
54 *
55 * This case (TRANS = 'T') is used to compute an one-norm-based estimate
56 * of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
57 * and (B,E), using DLACON.
58 *
59 * If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate
60 * of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the
61 * reciprocal of the smallest singular value of Z. See [1-2] for more
62 * information.
63 *
64 * This is a level 3 BLAS algorithm.
65 *
66 * Arguments
67 * =========
68 *
69 * TRANS (input) CHARACTER*1
70 * = 'N', solve the generalized Sylvester equation (1).
71 * = 'T', solve the 'transposed' system (3).
72 *
73 * IJOB (input) INTEGER
74 * Specifies what kind of functionality to be performed.
75 * =0: solve (1) only.
76 * =1: The functionality of 0 and 3.
77 * =2: The functionality of 0 and 4.
78 * =3: Only an estimate of Dif[(A,D), (B,E)] is computed.
79 * (look ahead strategy IJOB = 1 is used).
80 * =4: Only an estimate of Dif[(A,D), (B,E)] is computed.
81 * ( DGECON on sub-systems is used ).
82 * Not referenced if TRANS = 'T'.
83 *
84 * M (input) INTEGER
85 * The order of the matrices A and D, and the row dimension of
86 * the matrices C, F, R and L.
87 *
88 * N (input) INTEGER
89 * The order of the matrices B and E, and the column dimension
90 * of the matrices C, F, R and L.
91 *
92 * A (input) DOUBLE PRECISION array, dimension (LDA, M)
93 * The upper quasi triangular matrix A.
94 *
95 * LDA (input) INTEGER
96 * The leading dimension of the array A. LDA >= max(1, M).
97 *
98 * B (input) DOUBLE PRECISION array, dimension (LDB, N)
99 * The upper quasi triangular matrix B.
100 *
101 * LDB (input) INTEGER
102 * The leading dimension of the array B. LDB >= max(1, N).
103 *
104 * C (input/output) DOUBLE PRECISION array, dimension (LDC, N)
105 * On entry, C contains the right-hand-side of the first matrix
106 * equation in (1) or (3).
107 * On exit, if IJOB = 0, 1 or 2, C has been overwritten by
108 * the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R,
109 * the solution achieved during the computation of the
110 * Dif-estimate.
111 *
112 * LDC (input) INTEGER
113 * The leading dimension of the array C. LDC >= max(1, M).
114 *
115 * D (input) DOUBLE PRECISION array, dimension (LDD, M)
116 * The upper triangular matrix D.
117 *
118 * LDD (input) INTEGER
119 * The leading dimension of the array D. LDD >= max(1, M).
120 *
121 * E (input) DOUBLE PRECISION array, dimension (LDE, N)
122 * The upper triangular matrix E.
123 *
124 * LDE (input) INTEGER
125 * The leading dimension of the array E. LDE >= max(1, N).
126 *
127 * F (input/output) DOUBLE PRECISION array, dimension (LDF, N)
128 * On entry, F contains the right-hand-side of the second matrix
129 * equation in (1) or (3).
130 * On exit, if IJOB = 0, 1 or 2, F has been overwritten by
131 * the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L,
132 * the solution achieved during the computation of the
133 * Dif-estimate.
134 *
135 * LDF (input) INTEGER
136 * The leading dimension of the array F. LDF >= max(1, M).
137 *
138 * DIF (output) DOUBLE PRECISION
139 * On exit DIF is the reciprocal of a lower bound of the
140 * reciprocal of the Dif-function, i.e. DIF is an upper bound of
141 * Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2).
142 * IF IJOB = 0 or TRANS = 'T', DIF is not touched.
143 *
144 * SCALE (output) DOUBLE PRECISION
145 * On exit SCALE is the scaling factor in (1) or (3).
146 * If 0 < SCALE < 1, C and F hold the solutions R and L, resp.,
147 * to a slightly perturbed system but the input matrices A, B, D
148 * and E have not been changed. If SCALE = 0, C and F hold the
149 * solutions R and L, respectively, to the homogeneous system
150 * with C = F = 0. Normally, SCALE = 1.
151 *
152 * WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK)
153 * If IJOB = 0, WORK is not referenced. Otherwise,
154 * on exit, if INFO = 0, WORK(1) returns the optimal LWORK.
155 *
156 * LWORK (input) INTEGER
157 * The dimension of the array WORK. LWORK > = 1.
158 * If IJOB = 1 or 2 and TRANS = 'N', LWORK >= 2*M*N.
159 *
160 * If LWORK = -1, then a workspace query is assumed; the routine
161 * only calculates the optimal size of the WORK array, returns
162 * this value as the first entry of the WORK array, and no error
163 * message related to LWORK is issued by XERBLA.
164 *
165 * IWORK (workspace) INTEGER array, dimension (M+N+6)
166 *
167 * INFO (output) INTEGER
168 * =0: successful exit
169 * <0: If INFO = -i, the i-th argument had an illegal value.
170 * >0: (A, D) and (B, E) have common or close eigenvalues.
171 *
172 * Further Details
173 * ===============
174 *
175 * Based on contributions by
176 * Bo Kagstrom and Peter Poromaa, Department of Computing Science,
177 * Umea University, S-901 87 Umea, Sweden.
178 *
179 * [1] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software
180 * for Solving the Generalized Sylvester Equation and Estimating the
181 * Separation between Regular Matrix Pairs, Report UMINF - 93.23,
182 * Department of Computing Science, Umea University, S-901 87 Umea,
183 * Sweden, December 1993, Revised April 1994, Also as LAPACK Working
184 * Note 75. To appear in ACM Trans. on Math. Software, Vol 22,
185 * No 1, 1996.
186 *
187 * [2] B. Kagstrom, A Perturbation Analysis of the Generalized Sylvester
188 * Equation (AR - LB, DR - LE ) = (C, F), SIAM J. Matrix Anal.
189 * Appl., 15(4):1045-1060, 1994
190 *
191 * [3] B. Kagstrom and L. Westin, Generalized Schur Methods with
192 * Condition Estimators for Solving the Generalized Sylvester
193 * Equation, IEEE Transactions on Automatic Control, Vol. 34, No. 7,
194 * July 1989, pp 745-751.
195 *
196 * =====================================================================
197 *
198 * .. Parameters ..
199 DOUBLE PRECISION ZERO, ONE
200 PARAMETER ( ZERO = 0.0D+0, ONE = 1.0D+0 )
201 * ..
202 * .. Local Scalars ..
203 LOGICAL LQUERY, NOTRAN
204 INTEGER I, IE, IFUNC, IROUND, IS, ISOLVE, J, JE, JS, K,
205 $ LINFO, LWMIN, MB, NB, P, PPQQ, PQ, Q
206 DOUBLE PRECISION DSCALE, DSUM, SCALE2, SCALOC
207 * ..
208 * .. External Functions ..
209 LOGICAL LSAME
210 INTEGER ILAENV
211 EXTERNAL LSAME, ILAENV
212 * ..
213 * .. External Subroutines ..
214 EXTERNAL DCOPY, DGEMM, DLACPY, DSCAL, DTGSY2, XERBLA
215 * ..
216 * .. Intrinsic Functions ..
217 INTRINSIC DBLE, MAX, SQRT
218 * ..
219 * .. Executable Statements ..
220 *
221 * Decode and test input parameters
222 *
223 INFO = 0
224 NOTRAN = LSAME( TRANS, 'N' )
225 LQUERY = ( LWORK.EQ.-1 )
226 *
227 IF( ( IJOB.EQ.1 .OR. IJOB.EQ.2 ) .AND. NOTRAN ) THEN
228 LWMIN = MAX( 1, 2*M*N )
229 ELSE
230 LWMIN = 1
231 END IF
232 *
233 IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS, 'T' ) ) THEN
234 INFO = -1
235 ELSE IF( ( IJOB.LT.0 ) .OR. ( IJOB.GT.4 ) ) THEN
236 INFO = -2
237 ELSE IF( M.LE.0 ) THEN
238 INFO = -3
239 ELSE IF( N.LE.0 ) THEN
240 INFO = -4
241 ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
242 INFO = -6
243 ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
244 INFO = -8
245 ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
246 INFO = -10
247 ELSE IF( LDD.LT.MAX( 1, M ) ) THEN
248 INFO = -12
249 ELSE IF( LDE.LT.MAX( 1, N ) ) THEN
250 INFO = -14
251 ELSE IF( LDF.LT.MAX( 1, M ) ) THEN
252 INFO = -16
253 ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
254 INFO = -20
255 END IF
256 *
257 IF( INFO.EQ.0 ) THEN
258 WORK( 1 ) = LWMIN
259 END IF
260 *
261 IF( INFO.NE.0 ) THEN
262 CALL XERBLA( 'DTGSYL', -INFO )
263 RETURN
264 ELSE IF( LQUERY ) THEN
265 RETURN
266 END IF
267 *
268 * Determine optimal block sizes MB and NB
269 *
270 MB = ILAENV( 2, 'DTGSYL', TRANS, M, N, -1, -1 )
271 NB = ILAENV( 5, 'DTGSYL', TRANS, M, N, -1, -1 )
272 *
273 ISOLVE = 1
274 IFUNC = 0
275 IF( IJOB.GE.3 .AND. NOTRAN ) THEN
276 IFUNC = IJOB - 2
277 DO 10 J = 1, N
278 CALL DCOPY( M, ZERO, 0, C( 1, J ), 1 )
279 CALL DCOPY( M, ZERO, 0, F( 1, J ), 1 )
280 10 CONTINUE
281 ELSE IF( IJOB.GE.1 .AND. NOTRAN ) THEN
282 ISOLVE = 2
283 END IF
284 *
285 IF( ( MB.LE.1 .AND. NB.LE.1 ) .OR. ( MB.GE.M .AND. NB.GE.N ) )
286 $ THEN
287 *
288 DO 30 IROUND = 1, ISOLVE
289 *
290 * Use unblocked Level 2 solver
291 *
292 DSCALE = ZERO
293 DSUM = ONE
294 PQ = 0
295 CALL DTGSY2( TRANS, IFUNC, M, N, A, LDA, B, LDB, C, LDC, D,
296 $ LDD, E, LDE, F, LDF, SCALE, DSUM, DSCALE,
297 $ IWORK, PQ, INFO )
298 IF( DSCALE.NE.ZERO ) THEN
299 IF( IJOB.EQ.1 .OR. IJOB.EQ.3 ) THEN
300 DIF = SQRT( DBLE( 2*M*N ) ) / ( DSCALE*SQRT( DSUM ) )
301 ELSE
302 DIF = SQRT( DBLE( PQ ) ) / ( DSCALE*SQRT( DSUM ) )
303 END IF
304 END IF
305 *
306 IF( ISOLVE.EQ.2 .AND. IROUND.EQ.1 ) THEN
307 IFUNC = IJOB
308 SCALE2 = SCALE
309 CALL DLACPY( 'F', M, N, C, LDC, WORK, M )
310 CALL DLACPY( 'F', M, N, F, LDF, WORK( M*N+1 ), M )
311 DO 20 J = 1, N
312 CALL DCOPY( M, ZERO, 0, C( 1, J ), 1 )
313 CALL DCOPY( M, ZERO, 0, F( 1, J ), 1 )
314 20 CONTINUE
315 ELSE IF( ISOLVE.EQ.2 .AND. IROUND.EQ.2 ) THEN
316 CALL DLACPY( 'F', M, N, WORK, M, C, LDC )
317 CALL DLACPY( 'F', M, N, WORK( M*N+1 ), M, F, LDF )
318 SCALE = SCALE2
319 END IF
320 30 CONTINUE
321 *
322 RETURN
323 END IF
324 *
325 * Determine block structure of A
326 *
327 P = 0
328 I = 1
329 40 CONTINUE
330 IF( I.GT.M )
331 $ GO TO 50
332 P = P + 1
333 IWORK( P ) = I
334 I = I + MB
335 IF( I.GE.M )
336 $ GO TO 50
337 IF( A( I, I-1 ).NE.ZERO )
338 $ I = I + 1
339 GO TO 40
340 50 CONTINUE
341 *
342 IWORK( P+1 ) = M + 1
343 IF( IWORK( P ).EQ.IWORK( P+1 ) )
344 $ P = P - 1
345 *
346 * Determine block structure of B
347 *
348 Q = P + 1
349 J = 1
350 60 CONTINUE
351 IF( J.GT.N )
352 $ GO TO 70
353 Q = Q + 1
354 IWORK( Q ) = J
355 J = J + NB
356 IF( J.GE.N )
357 $ GO TO 70
358 IF( B( J, J-1 ).NE.ZERO )
359 $ J = J + 1
360 GO TO 60
361 70 CONTINUE
362 *
363 IWORK( Q+1 ) = N + 1
364 IF( IWORK( Q ).EQ.IWORK( Q+1 ) )
365 $ Q = Q - 1
366 *
367 IF( NOTRAN ) THEN
368 *
369 DO 150 IROUND = 1, ISOLVE
370 *
371 * Solve (I, J)-subsystem
372 * A(I, I) * R(I, J) - L(I, J) * B(J, J) = C(I, J)
373 * D(I, I) * R(I, J) - L(I, J) * E(J, J) = F(I, J)
374 * for I = P, P - 1,..., 1; J = 1, 2,..., Q
375 *
376 DSCALE = ZERO
377 DSUM = ONE
378 PQ = 0
379 SCALE = ONE
380 DO 130 J = P + 2, Q
381 JS = IWORK( J )
382 JE = IWORK( J+1 ) - 1
383 NB = JE - JS + 1
384 DO 120 I = P, 1, -1
385 IS = IWORK( I )
386 IE = IWORK( I+1 ) - 1
387 MB = IE - IS + 1
388 PPQQ = 0
389 CALL DTGSY2( TRANS, IFUNC, MB, NB, A( IS, IS ), LDA,
390 $ B( JS, JS ), LDB, C( IS, JS ), LDC,
391 $ D( IS, IS ), LDD, E( JS, JS ), LDE,
392 $ F( IS, JS ), LDF, SCALOC, DSUM, DSCALE,
393 $ IWORK( Q+2 ), PPQQ, LINFO )
394 IF( LINFO.GT.0 )
395 $ INFO = LINFO
396 *
397 PQ = PQ + PPQQ
398 IF( SCALOC.NE.ONE ) THEN
399 DO 80 K = 1, JS - 1
400 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
401 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
402 80 CONTINUE
403 DO 90 K = JS, JE
404 CALL DSCAL( IS-1, SCALOC, C( 1, K ), 1 )
405 CALL DSCAL( IS-1, SCALOC, F( 1, K ), 1 )
406 90 CONTINUE
407 DO 100 K = JS, JE
408 CALL DSCAL( M-IE, SCALOC, C( IE+1, K ), 1 )
409 CALL DSCAL( M-IE, SCALOC, F( IE+1, K ), 1 )
410 100 CONTINUE
411 DO 110 K = JE + 1, N
412 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
413 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
414 110 CONTINUE
415 SCALE = SCALE*SCALOC
416 END IF
417 *
418 * Substitute R(I, J) and L(I, J) into remaining
419 * equation.
420 *
421 IF( I.GT.1 ) THEN
422 CALL DGEMM( 'N', 'N', IS-1, NB, MB, -ONE,
423 $ A( 1, IS ), LDA, C( IS, JS ), LDC, ONE,
424 $ C( 1, JS ), LDC )
425 CALL DGEMM( 'N', 'N', IS-1, NB, MB, -ONE,
426 $ D( 1, IS ), LDD, C( IS, JS ), LDC, ONE,
427 $ F( 1, JS ), LDF )
428 END IF
429 IF( J.LT.Q ) THEN
430 CALL DGEMM( 'N', 'N', MB, N-JE, NB, ONE,
431 $ F( IS, JS ), LDF, B( JS, JE+1 ), LDB,
432 $ ONE, C( IS, JE+1 ), LDC )
433 CALL DGEMM( 'N', 'N', MB, N-JE, NB, ONE,
434 $ F( IS, JS ), LDF, E( JS, JE+1 ), LDE,
435 $ ONE, F( IS, JE+1 ), LDF )
436 END IF
437 120 CONTINUE
438 130 CONTINUE
439 IF( DSCALE.NE.ZERO ) THEN
440 IF( IJOB.EQ.1 .OR. IJOB.EQ.3 ) THEN
441 DIF = SQRT( DBLE( 2*M*N ) ) / ( DSCALE*SQRT( DSUM ) )
442 ELSE
443 DIF = SQRT( DBLE( PQ ) ) / ( DSCALE*SQRT( DSUM ) )
444 END IF
445 END IF
446 IF( ISOLVE.EQ.2 .AND. IROUND.EQ.1 ) THEN
447 IFUNC = IJOB
448 SCALE2 = SCALE
449 CALL DLACPY( 'F', M, N, C, LDC, WORK, M )
450 CALL DLACPY( 'F', M, N, F, LDF, WORK( M*N+1 ), M )
451 DO 140 J = 1, N
452 CALL DCOPY( M, ZERO, 0, C( 1, J ), 1 )
453 CALL DCOPY( M, ZERO, 0, F( 1, J ), 1 )
454 140 CONTINUE
455 ELSE IF( ISOLVE.EQ.2 .AND. IROUND.EQ.2 ) THEN
456 CALL DLACPY( 'F', M, N, WORK, M, C, LDC )
457 CALL DLACPY( 'F', M, N, WORK( M*N+1 ), M, F, LDF )
458 SCALE = SCALE2
459 END IF
460 150 CONTINUE
461 *
462 ELSE
463 *
464 * Solve transposed (I, J)-subsystem
465 * A(I, I)' * R(I, J) + D(I, I)' * L(I, J) = C(I, J)
466 * R(I, J) * B(J, J)' + L(I, J) * E(J, J)' = -F(I, J)
467 * for I = 1,2,..., P; J = Q, Q-1,..., 1
468 *
469 SCALE = ONE
470 DO 210 I = 1, P
471 IS = IWORK( I )
472 IE = IWORK( I+1 ) - 1
473 MB = IE - IS + 1
474 DO 200 J = Q, P + 2, -1
475 JS = IWORK( J )
476 JE = IWORK( J+1 ) - 1
477 NB = JE - JS + 1
478 CALL DTGSY2( TRANS, IFUNC, MB, NB, A( IS, IS ), LDA,
479 $ B( JS, JS ), LDB, C( IS, JS ), LDC,
480 $ D( IS, IS ), LDD, E( JS, JS ), LDE,
481 $ F( IS, JS ), LDF, SCALOC, DSUM, DSCALE,
482 $ IWORK( Q+2 ), PPQQ, LINFO )
483 IF( LINFO.GT.0 )
484 $ INFO = LINFO
485 IF( SCALOC.NE.ONE ) THEN
486 DO 160 K = 1, JS - 1
487 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
488 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
489 160 CONTINUE
490 DO 170 K = JS, JE
491 CALL DSCAL( IS-1, SCALOC, C( 1, K ), 1 )
492 CALL DSCAL( IS-1, SCALOC, F( 1, K ), 1 )
493 170 CONTINUE
494 DO 180 K = JS, JE
495 CALL DSCAL( M-IE, SCALOC, C( IE+1, K ), 1 )
496 CALL DSCAL( M-IE, SCALOC, F( IE+1, K ), 1 )
497 180 CONTINUE
498 DO 190 K = JE + 1, N
499 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
500 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
501 190 CONTINUE
502 SCALE = SCALE*SCALOC
503 END IF
504 *
505 * Substitute R(I, J) and L(I, J) into remaining equation.
506 *
507 IF( J.GT.P+2 ) THEN
508 CALL DGEMM( 'N', 'T', MB, JS-1, NB, ONE, C( IS, JS ),
509 $ LDC, B( 1, JS ), LDB, ONE, F( IS, 1 ),
510 $ LDF )
511 CALL DGEMM( 'N', 'T', MB, JS-1, NB, ONE, F( IS, JS ),
512 $ LDF, E( 1, JS ), LDE, ONE, F( IS, 1 ),
513 $ LDF )
514 END IF
515 IF( I.LT.P ) THEN
516 CALL DGEMM( 'T', 'N', M-IE, NB, MB, -ONE,
517 $ A( IS, IE+1 ), LDA, C( IS, JS ), LDC, ONE,
518 $ C( IE+1, JS ), LDC )
519 CALL DGEMM( 'T', 'N', M-IE, NB, MB, -ONE,
520 $ D( IS, IE+1 ), LDD, F( IS, JS ), LDF, ONE,
521 $ C( IE+1, JS ), LDC )
522 END IF
523 200 CONTINUE
524 210 CONTINUE
525 *
526 END IF
527 *
528 WORK( 1 ) = LWMIN
529 *
530 RETURN
531 *
532 * End of DTGSYL
533 *
534 END