Debian Codegraph @

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

raw
1 SUBROUTINE DTGSY2( TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D,
2 $ LDD, E, LDE, F, LDF, SCALE, RDSUM, RDSCAL,
3 $ IWORK, PQ, INFO )
4 *
5 * -- LAPACK auxiliary 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, M, N,
13 $ PQ
14 DOUBLE PRECISION RDSCAL, RDSUM, 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 * ..
21 *
22 * Purpose
23 * =======
24 *
25 * DTGSY2 solves the generalized Sylvester equation:
26 *
27 * A * R - L * B = scale * C (1)
28 * D * R - L * E = scale * F,
29 *
30 * using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices,
31 * (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,
32 * N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E)
33 * must be in generalized Schur canonical form, i.e. A, B are upper
34 * quasi triangular and D, E are upper triangular. The solution (R, L)
35 * overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor
36 * chosen to avoid overflow.
37 *
38 * In matrix notation solving equation (1) corresponds to solve
39 * Z*x = scale*b, where Z is defined as
40 *
41 * Z = [ kron(In, A) -kron(B', Im) ] (2)
42 * [ kron(In, D) -kron(E', Im) ],
43 *
44 * Ik is the identity matrix of size k and X' is the transpose of X.
45 * kron(X, Y) is the Kronecker product between the matrices X and Y.
46 * In the process of solving (1), we solve a number of such systems
47 * where Dim(In), Dim(In) = 1 or 2.
48 *
49 * If TRANS = 'T', solve the transposed system Z'*y = scale*b for y,
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 is used to compute an estimate of Dif[(A, D), (B, E)] =
56 * sigma_min(Z) using reverse communicaton with DLACON.
57 *
58 * DTGSY2 also (IJOB >= 1) contributes to the computation in STGSYL
59 * of an upper bound on the separation between to matrix pairs. Then
60 * the input (A, D), (B, E) are sub-pencils of the matrix pair in
61 * DTGSYL. See STGSYL for details.
62 *
63 * Arguments
64 * =========
65 *
66 * TRANS (input) CHARACTER
67 * = 'N', solve the generalized Sylvester equation (1).
68 * = 'T': solve the 'transposed' system (3).
69 *
70 * IJOB (input) INTEGER
71 * Specifies what kind of functionality to be performed.
72 * = 0: solve (1) only.
73 * = 1: A contribution from this subsystem to a Frobenius
74 * norm-based estimate of the separation between two matrix
75 * pairs is computed. (look ahead strategy is used).
76 * = 2: A contribution from this subsystem to a Frobenius
77 * norm-based estimate of the separation between two matrix
78 * pairs is computed. (DGECON on sub-systems is used.)
79 * Not referenced if TRANS = 'T'.
80 *
81 * M (input) INTEGER
82 * On entry, M specifies the order of A and D, and the row
83 * dimension of C, F, R and L.
84 *
85 * N (input) INTEGER
86 * On entry, N specifies the order of B and E, and the column
87 * dimension of C, F, R and L.
88 *
89 * A (input) DOUBLE PRECISION array, dimension (LDA, M)
90 * On entry, A contains an upper quasi triangular matrix.
91 *
92 * LDA (input) INTEGER
93 * The leading dimension of the matrix A. LDA >= max(1, M).
94 *
95 * B (input) DOUBLE PRECISION array, dimension (LDB, N)
96 * On entry, B contains an upper quasi triangular matrix.
97 *
98 * LDB (input) INTEGER
99 * The leading dimension of the matrix B. LDB >= max(1, N).
100 *
101 * C (input/ output) DOUBLE PRECISION array, dimension (LDC, N)
102 * On entry, C contains the right-hand-side of the first matrix
103 * equation in (1).
104 * On exit, if IJOB = 0, C has been overwritten by the
105 * solution R.
106 *
107 * LDC (input) INTEGER
108 * The leading dimension of the matrix C. LDC >= max(1, M).
109 *
110 * D (input) DOUBLE PRECISION array, dimension (LDD, M)
111 * On entry, D contains an upper triangular matrix.
112 *
113 * LDD (input) INTEGER
114 * The leading dimension of the matrix D. LDD >= max(1, M).
115 *
116 * E (input) DOUBLE PRECISION array, dimension (LDE, N)
117 * On entry, E contains an upper triangular matrix.
118 *
119 * LDE (input) INTEGER
120 * The leading dimension of the matrix E. LDE >= max(1, N).
121 *
122 * F (input/ output) DOUBLE PRECISION array, dimension (LDF, N)
123 * On entry, F contains the right-hand-side of the second matrix
124 * equation in (1).
125 * On exit, if IJOB = 0, F has been overwritten by the
126 * solution L.
127 *
128 * LDF (input) INTEGER
129 * The leading dimension of the matrix F. LDF >= max(1, M).
130 *
131 * SCALE (output) DOUBLE PRECISION
132 * On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions
133 * R and L (C and F on entry) will hold the solutions to a
134 * slightly perturbed system but the input matrices A, B, D and
135 * E have not been changed. If SCALE = 0, R and L will hold the
136 * solutions to the homogeneous system with C = F = 0. Normally,
137 * SCALE = 1.
138 *
139 * RDSUM (input/output) DOUBLE PRECISION
140 * On entry, the sum of squares of computed contributions to
141 * the Dif-estimate under computation by DTGSYL, where the
142 * scaling factor RDSCAL (see below) has been factored out.
143 * On exit, the corresponding sum of squares updated with the
144 * contributions from the current sub-system.
145 * If TRANS = 'T' RDSUM is not touched.
146 * NOTE: RDSUM only makes sense when DTGSY2 is called by STGSYL.
147 *
148 * RDSCAL (input/output) DOUBLE PRECISION
149 * On entry, scaling factor used to prevent overflow in RDSUM.
150 * On exit, RDSCAL is updated w.r.t. the current contributions
151 * in RDSUM.
152 * If TRANS = 'T', RDSCAL is not touched.
153 * NOTE: RDSCAL only makes sense when DTGSY2 is called by
154 * DTGSYL.
155 *
156 * IWORK (workspace) INTEGER array, dimension (M+N+2)
157 *
158 * PQ (output) INTEGER
159 * On exit, the number of subsystems (of size 2-by-2, 4-by-4 and
160 * 8-by-8) solved by this routine.
161 *
162 * INFO (output) INTEGER
163 * On exit, if INFO is set to
164 * =0: Successful exit
165 * <0: If INFO = -i, the i-th argument had an illegal value.
166 * >0: The matrix pairs (A, D) and (B, E) have common or very
167 * close eigenvalues.
168 *
169 * Further Details
170 * ===============
171 *
172 * Based on contributions by
173 * Bo Kagstrom and Peter Poromaa, Department of Computing Science,
174 * Umea University, S-901 87 Umea, Sweden.
175 *
176 * =====================================================================
177 *
178 * .. Parameters ..
179 INTEGER LDZ
180 PARAMETER ( LDZ = 8 )
181 DOUBLE PRECISION ZERO, ONE
182 PARAMETER ( ZERO = 0.0D+0, ONE = 1.0D+0 )
183 * ..
184 * .. Local Scalars ..
185 LOGICAL NOTRAN
186 INTEGER I, IE, IERR, II, IS, ISP1, J, JE, JJ, JS, JSP1,
187 $ K, MB, NB, P, Q, ZDIM
188 DOUBLE PRECISION ALPHA, SCALOC
189 * ..
190 * .. Local Arrays ..
191 INTEGER IPIV( LDZ ), JPIV( LDZ )
192 DOUBLE PRECISION RHS( LDZ ), Z( LDZ, LDZ )
193 * ..
194 * .. External Functions ..
195 LOGICAL LSAME
196 EXTERNAL LSAME
197 * ..
198 * .. External Subroutines ..
199 EXTERNAL DAXPY, DCOPY, DGEMM, DGEMV, DGER, DGESC2,
200 $ DGETC2, DLATDF, DSCAL, XERBLA
201 * ..
202 * .. Intrinsic Functions ..
203 INTRINSIC MAX
204 * ..
205 * .. Executable Statements ..
206 *
207 * Decode and test input parameters
208 *
209 INFO = 0
210 IERR = 0
211 NOTRAN = LSAME( TRANS, 'N' )
212 IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS, 'T' ) ) THEN
213 INFO = -1
214 ELSE IF( ( IJOB.LT.0 ) .OR. ( IJOB.GT.2 ) ) THEN
215 INFO = -2
216 ELSE IF( M.LE.0 ) THEN
217 INFO = -3
218 ELSE IF( N.LE.0 ) THEN
219 INFO = -4
220 ELSE IF( LDA.LT.MAX( 1, M ) ) THEN
221 INFO = -5
222 ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
223 INFO = -8
224 ELSE IF( LDC.LT.MAX( 1, M ) ) THEN
225 INFO = -10
226 ELSE IF( LDD.LT.MAX( 1, M ) ) THEN
227 INFO = -12
228 ELSE IF( LDE.LT.MAX( 1, N ) ) THEN
229 INFO = -14
230 ELSE IF( LDF.LT.MAX( 1, M ) ) THEN
231 INFO = -16
232 END IF
233 IF( INFO.NE.0 ) THEN
234 CALL XERBLA( 'DTGSY2', -INFO )
235 RETURN
236 END IF
237 *
238 * Determine block structure of A
239 *
240 PQ = 0
241 P = 0
242 I = 1
243 10 CONTINUE
244 IF( I.GT.M )
245 $ GO TO 20
246 P = P + 1
247 IWORK( P ) = I
248 IF( I.EQ.M )
249 $ GO TO 20
250 IF( A( I+1, I ).NE.ZERO ) THEN
251 I = I + 2
252 ELSE
253 I = I + 1
254 END IF
255 GO TO 10
256 20 CONTINUE
257 IWORK( P+1 ) = M + 1
258 *
259 * Determine block structure of B
260 *
261 Q = P + 1
262 J = 1
263 30 CONTINUE
264 IF( J.GT.N )
265 $ GO TO 40
266 Q = Q + 1
267 IWORK( Q ) = J
268 IF( J.EQ.N )
269 $ GO TO 40
270 IF( B( J+1, J ).NE.ZERO ) THEN
271 J = J + 2
272 ELSE
273 J = J + 1
274 END IF
275 GO TO 30
276 40 CONTINUE
277 IWORK( Q+1 ) = N + 1
278 PQ = P*( Q-P-1 )
279 *
280 IF( NOTRAN ) THEN
281 *
282 * Solve (I, J) - subsystem
283 * A(I, I) * R(I, J) - L(I, J) * B(J, J) = C(I, J)
284 * D(I, I) * R(I, J) - L(I, J) * E(J, J) = F(I, J)
285 * for I = P, P - 1, ..., 1; J = 1, 2, ..., Q
286 *
287 SCALE = ONE
288 SCALOC = ONE
289 DO 120 J = P + 2, Q
290 JS = IWORK( J )
291 JSP1 = JS + 1
292 JE = IWORK( J+1 ) - 1
293 NB = JE - JS + 1
294 DO 110 I = P, 1, -1
295 *
296 IS = IWORK( I )
297 ISP1 = IS + 1
298 IE = IWORK( I+1 ) - 1
299 MB = IE - IS + 1
300 ZDIM = MB*NB*2
301 *
302 IF( ( MB.EQ.1 ) .AND. ( NB.EQ.1 ) ) THEN
303 *
304 * Build a 2-by-2 system Z * x = RHS
305 *
306 Z( 1, 1 ) = A( IS, IS )
307 Z( 2, 1 ) = D( IS, IS )
308 Z( 1, 2 ) = -B( JS, JS )
309 Z( 2, 2 ) = -E( JS, JS )
310 *
311 * Set up right hand side(s)
312 *
313 RHS( 1 ) = C( IS, JS )
314 RHS( 2 ) = F( IS, JS )
315 *
316 * Solve Z * x = RHS
317 *
318 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
319 IF( IERR.GT.0 )
320 $ INFO = IERR
321 *
322 IF( IJOB.EQ.0 ) THEN
323 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV,
324 $ SCALOC )
325 IF( SCALOC.NE.ONE ) THEN
326 DO 50 K = 1, N
327 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
328 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
329 50 CONTINUE
330 SCALE = SCALE*SCALOC
331 END IF
332 ELSE
333 CALL DLATDF( IJOB, ZDIM, Z, LDZ, RHS, RDSUM,
334 $ RDSCAL, IPIV, JPIV )
335 END IF
336 *
337 * Unpack solution vector(s)
338 *
339 C( IS, JS ) = RHS( 1 )
340 F( IS, JS ) = RHS( 2 )
341 *
342 * Substitute R(I, J) and L(I, J) into remaining
343 * equation.
344 *
345 IF( I.GT.1 ) THEN
346 ALPHA = -RHS( 1 )
347 CALL DAXPY( IS-1, ALPHA, A( 1, IS ), 1, C( 1, JS ),
348 $ 1 )
349 CALL DAXPY( IS-1, ALPHA, D( 1, IS ), 1, F( 1, JS ),
350 $ 1 )
351 END IF
352 IF( J.LT.Q ) THEN
353 CALL DAXPY( N-JE, RHS( 2 ), B( JS, JE+1 ), LDB,
354 $ C( IS, JE+1 ), LDC )
355 CALL DAXPY( N-JE, RHS( 2 ), E( JS, JE+1 ), LDE,
356 $ F( IS, JE+1 ), LDF )
357 END IF
358 *
359 ELSE IF( ( MB.EQ.1 ) .AND. ( NB.EQ.2 ) ) THEN
360 *
361 * Build a 4-by-4 system Z * x = RHS
362 *
363 Z( 1, 1 ) = A( IS, IS )
364 Z( 2, 1 ) = ZERO
365 Z( 3, 1 ) = D( IS, IS )
366 Z( 4, 1 ) = ZERO
367 *
368 Z( 1, 2 ) = ZERO
369 Z( 2, 2 ) = A( IS, IS )
370 Z( 3, 2 ) = ZERO
371 Z( 4, 2 ) = D( IS, IS )
372 *
373 Z( 1, 3 ) = -B( JS, JS )
374 Z( 2, 3 ) = -B( JS, JSP1 )
375 Z( 3, 3 ) = -E( JS, JS )
376 Z( 4, 3 ) = -E( JS, JSP1 )
377 *
378 Z( 1, 4 ) = -B( JSP1, JS )
379 Z( 2, 4 ) = -B( JSP1, JSP1 )
380 Z( 3, 4 ) = ZERO
381 Z( 4, 4 ) = -E( JSP1, JSP1 )
382 *
383 * Set up right hand side(s)
384 *
385 RHS( 1 ) = C( IS, JS )
386 RHS( 2 ) = C( IS, JSP1 )
387 RHS( 3 ) = F( IS, JS )
388 RHS( 4 ) = F( IS, JSP1 )
389 *
390 * Solve Z * x = RHS
391 *
392 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
393 IF( IERR.GT.0 )
394 $ INFO = IERR
395 *
396 IF( IJOB.EQ.0 ) THEN
397 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV,
398 $ SCALOC )
399 IF( SCALOC.NE.ONE ) THEN
400 DO 60 K = 1, N
401 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
402 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
403 60 CONTINUE
404 SCALE = SCALE*SCALOC
405 END IF
406 ELSE
407 CALL DLATDF( IJOB, ZDIM, Z, LDZ, RHS, RDSUM,
408 $ RDSCAL, IPIV, JPIV )
409 END IF
410 *
411 * Unpack solution vector(s)
412 *
413 C( IS, JS ) = RHS( 1 )
414 C( IS, JSP1 ) = RHS( 2 )
415 F( IS, JS ) = RHS( 3 )
416 F( IS, JSP1 ) = RHS( 4 )
417 *
418 * Substitute R(I, J) and L(I, J) into remaining
419 * equation.
420 *
421 IF( I.GT.1 ) THEN
422 CALL DGER( IS-1, NB, -ONE, A( 1, IS ), 1, RHS( 1 ),
423 $ 1, C( 1, JS ), LDC )
424 CALL DGER( IS-1, NB, -ONE, D( 1, IS ), 1, RHS( 1 ),
425 $ 1, F( 1, JS ), LDF )
426 END IF
427 IF( J.LT.Q ) THEN
428 CALL DAXPY( N-JE, RHS( 3 ), B( JS, JE+1 ), LDB,
429 $ C( IS, JE+1 ), LDC )
430 CALL DAXPY( N-JE, RHS( 3 ), E( JS, JE+1 ), LDE,
431 $ F( IS, JE+1 ), LDF )
432 CALL DAXPY( N-JE, RHS( 4 ), B( JSP1, JE+1 ), LDB,
433 $ C( IS, JE+1 ), LDC )
434 CALL DAXPY( N-JE, RHS( 4 ), E( JSP1, JE+1 ), LDE,
435 $ F( IS, JE+1 ), LDF )
436 END IF
437 *
438 ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.1 ) ) THEN
439 *
440 * Build a 4-by-4 system Z * x = RHS
441 *
442 Z( 1, 1 ) = A( IS, IS )
443 Z( 2, 1 ) = A( ISP1, IS )
444 Z( 3, 1 ) = D( IS, IS )
445 Z( 4, 1 ) = ZERO
446 *
447 Z( 1, 2 ) = A( IS, ISP1 )
448 Z( 2, 2 ) = A( ISP1, ISP1 )
449 Z( 3, 2 ) = D( IS, ISP1 )
450 Z( 4, 2 ) = D( ISP1, ISP1 )
451 *
452 Z( 1, 3 ) = -B( JS, JS )
453 Z( 2, 3 ) = ZERO
454 Z( 3, 3 ) = -E( JS, JS )
455 Z( 4, 3 ) = ZERO
456 *
457 Z( 1, 4 ) = ZERO
458 Z( 2, 4 ) = -B( JS, JS )
459 Z( 3, 4 ) = ZERO
460 Z( 4, 4 ) = -E( JS, JS )
461 *
462 * Set up right hand side(s)
463 *
464 RHS( 1 ) = C( IS, JS )
465 RHS( 2 ) = C( ISP1, JS )
466 RHS( 3 ) = F( IS, JS )
467 RHS( 4 ) = F( ISP1, JS )
468 *
469 * Solve Z * x = RHS
470 *
471 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
472 IF( IERR.GT.0 )
473 $ INFO = IERR
474 IF( IJOB.EQ.0 ) THEN
475 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV,
476 $ SCALOC )
477 IF( SCALOC.NE.ONE ) THEN
478 DO 70 K = 1, N
479 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
480 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
481 70 CONTINUE
482 SCALE = SCALE*SCALOC
483 END IF
484 ELSE
485 CALL DLATDF( IJOB, ZDIM, Z, LDZ, RHS, RDSUM,
486 $ RDSCAL, IPIV, JPIV )
487 END IF
488 *
489 * Unpack solution vector(s)
490 *
491 C( IS, JS ) = RHS( 1 )
492 C( ISP1, JS ) = RHS( 2 )
493 F( IS, JS ) = RHS( 3 )
494 F( ISP1, JS ) = RHS( 4 )
495 *
496 * Substitute R(I, J) and L(I, J) into remaining
497 * equation.
498 *
499 IF( I.GT.1 ) THEN
500 CALL DGEMV( 'N', IS-1, MB, -ONE, A( 1, IS ), LDA,
501 $ RHS( 1 ), 1, ONE, C( 1, JS ), 1 )
502 CALL DGEMV( 'N', IS-1, MB, -ONE, D( 1, IS ), LDD,
503 $ RHS( 1 ), 1, ONE, F( 1, JS ), 1 )
504 END IF
505 IF( J.LT.Q ) THEN
506 CALL DGER( MB, N-JE, ONE, RHS( 3 ), 1,
507 $ B( JS, JE+1 ), LDB, C( IS, JE+1 ), LDC )
508 CALL DGER( MB, N-JE, ONE, RHS( 3 ), 1,
509 $ E( JS, JE+1 ), LDB, F( IS, JE+1 ), LDC )
510 END IF
511 *
512 ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.2 ) ) THEN
513 *
514 * Build an 8-by-8 system Z * x = RHS
515 *
516 CALL DCOPY( LDZ*LDZ, ZERO, 0, Z, 1 )
517 *
518 Z( 1, 1 ) = A( IS, IS )
519 Z( 2, 1 ) = A( ISP1, IS )
520 Z( 5, 1 ) = D( IS, IS )
521 *
522 Z( 1, 2 ) = A( IS, ISP1 )
523 Z( 2, 2 ) = A( ISP1, ISP1 )
524 Z( 5, 2 ) = D( IS, ISP1 )
525 Z( 6, 2 ) = D( ISP1, ISP1 )
526 *
527 Z( 3, 3 ) = A( IS, IS )
528 Z( 4, 3 ) = A( ISP1, IS )
529 Z( 7, 3 ) = D( IS, IS )
530 *
531 Z( 3, 4 ) = A( IS, ISP1 )
532 Z( 4, 4 ) = A( ISP1, ISP1 )
533 Z( 7, 4 ) = D( IS, ISP1 )
534 Z( 8, 4 ) = D( ISP1, ISP1 )
535 *
536 Z( 1, 5 ) = -B( JS, JS )
537 Z( 3, 5 ) = -B( JS, JSP1 )
538 Z( 5, 5 ) = -E( JS, JS )
539 Z( 7, 5 ) = -E( JS, JSP1 )
540 *
541 Z( 2, 6 ) = -B( JS, JS )
542 Z( 4, 6 ) = -B( JS, JSP1 )
543 Z( 6, 6 ) = -E( JS, JS )
544 Z( 8, 6 ) = -E( JS, JSP1 )
545 *
546 Z( 1, 7 ) = -B( JSP1, JS )
547 Z( 3, 7 ) = -B( JSP1, JSP1 )
548 Z( 7, 7 ) = -E( JSP1, JSP1 )
549 *
550 Z( 2, 8 ) = -B( JSP1, JS )
551 Z( 4, 8 ) = -B( JSP1, JSP1 )
552 Z( 8, 8 ) = -E( JSP1, JSP1 )
553 *
554 * Set up right hand side(s)
555 *
556 K = 1
557 II = MB*NB + 1
558 DO 80 JJ = 0, NB - 1
559 CALL DCOPY( MB, C( IS, JS+JJ ), 1, RHS( K ), 1 )
560 CALL DCOPY( MB, F( IS, JS+JJ ), 1, RHS( II ), 1 )
561 K = K + MB
562 II = II + MB
563 80 CONTINUE
564 *
565 * Solve Z * x = RHS
566 *
567 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
568 IF( IERR.GT.0 )
569 $ INFO = IERR
570 IF( IJOB.EQ.0 ) THEN
571 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV,
572 $ SCALOC )
573 IF( SCALOC.NE.ONE ) THEN
574 DO 90 K = 1, N
575 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
576 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
577 90 CONTINUE
578 SCALE = SCALE*SCALOC
579 END IF
580 ELSE
581 CALL DLATDF( IJOB, ZDIM, Z, LDZ, RHS, RDSUM,
582 $ RDSCAL, IPIV, JPIV )
583 END IF
584 *
585 * Unpack solution vector(s)
586 *
587 K = 1
588 II = MB*NB + 1
589 DO 100 JJ = 0, NB - 1
590 CALL DCOPY( MB, RHS( K ), 1, C( IS, JS+JJ ), 1 )
591 CALL DCOPY( MB, RHS( II ), 1, F( IS, JS+JJ ), 1 )
592 K = K + MB
593 II = II + MB
594 100 CONTINUE
595 *
596 * Substitute R(I, J) and L(I, J) into remaining
597 * equation.
598 *
599 IF( I.GT.1 ) THEN
600 CALL DGEMM( 'N', 'N', IS-1, NB, MB, -ONE,
601 $ A( 1, IS ), LDA, RHS( 1 ), MB, ONE,
602 $ C( 1, JS ), LDC )
603 CALL DGEMM( 'N', 'N', IS-1, NB, MB, -ONE,
604 $ D( 1, IS ), LDD, RHS( 1 ), MB, ONE,
605 $ F( 1, JS ), LDF )
606 END IF
607 IF( J.LT.Q ) THEN
608 K = MB*NB + 1
609 CALL DGEMM( 'N', 'N', MB, N-JE, NB, ONE, RHS( K ),
610 $ MB, B( JS, JE+1 ), LDB, ONE,
611 $ C( IS, JE+1 ), LDC )
612 CALL DGEMM( 'N', 'N', MB, N-JE, NB, ONE, RHS( K ),
613 $ MB, E( JS, JE+1 ), LDE, ONE,
614 $ F( IS, JE+1 ), LDF )
615 END IF
616 *
617 END IF
618 *
619 110 CONTINUE
620 120 CONTINUE
621 ELSE
622 *
623 * Solve (I, J) - subsystem
624 * A(I, I)' * R(I, J) + D(I, I)' * L(J, J) = C(I, J)
625 * R(I, I) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
626 * for I = 1, 2, ..., P, J = Q, Q - 1, ..., 1
627 *
628 SCALE = ONE
629 SCALOC = ONE
630 DO 200 I = 1, P
631 *
632 IS = IWORK( I )
633 ISP1 = IS + 1
634 IE = IWORK( I+1 ) - 1
635 MB = IE - IS + 1
636 DO 190 J = Q, P + 2, -1
637 *
638 JS = IWORK( J )
639 JSP1 = JS + 1
640 JE = IWORK( J+1 ) - 1
641 NB = JE - JS + 1
642 ZDIM = MB*NB*2
643 IF( ( MB.EQ.1 ) .AND. ( NB.EQ.1 ) ) THEN
644 *
645 * Build a 2-by-2 system Z' * x = RHS
646 *
647 Z( 1, 1 ) = A( IS, IS )
648 Z( 2, 1 ) = -B( JS, JS )
649 Z( 1, 2 ) = D( IS, IS )
650 Z( 2, 2 ) = -E( JS, JS )
651 *
652 * Set up right hand side(s)
653 *
654 RHS( 1 ) = C( IS, JS )
655 RHS( 2 ) = F( IS, JS )
656 *
657 * Solve Z' * x = RHS
658 *
659 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
660 IF( IERR.GT.0 )
661 $ INFO = IERR
662 *
663 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV, SCALOC )
664 IF( SCALOC.NE.ONE ) THEN
665 DO 130 K = 1, N
666 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
667 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
668 130 CONTINUE
669 SCALE = SCALE*SCALOC
670 END IF
671 *
672 * Unpack solution vector(s)
673 *
674 C( IS, JS ) = RHS( 1 )
675 F( IS, JS ) = RHS( 2 )
676 *
677 * Substitute R(I, J) and L(I, J) into remaining
678 * equation.
679 *
680 IF( J.GT.P+2 ) THEN
681 ALPHA = RHS( 1 )
682 CALL DAXPY( JS-1, ALPHA, B( 1, JS ), 1, F( IS, 1 ),
683 $ LDF )
684 ALPHA = RHS( 2 )
685 CALL DAXPY( JS-1, ALPHA, E( 1, JS ), 1, F( IS, 1 ),
686 $ LDF )
687 END IF
688 IF( I.LT.P ) THEN
689 ALPHA = -RHS( 1 )
690 CALL DAXPY( M-IE, ALPHA, A( IS, IE+1 ), LDA,
691 $ C( IE+1, JS ), 1 )
692 ALPHA = -RHS( 2 )
693 CALL DAXPY( M-IE, ALPHA, D( IS, IE+1 ), LDD,
694 $ C( IE+1, JS ), 1 )
695 END IF
696 *
697 ELSE IF( ( MB.EQ.1 ) .AND. ( NB.EQ.2 ) ) THEN
698 *
699 * Build a 4-by-4 system Z' * x = RHS
700 *
701 Z( 1, 1 ) = A( IS, IS )
702 Z( 2, 1 ) = ZERO
703 Z( 3, 1 ) = -B( JS, JS )
704 Z( 4, 1 ) = -B( JSP1, JS )
705 *
706 Z( 1, 2 ) = ZERO
707 Z( 2, 2 ) = A( IS, IS )
708 Z( 3, 2 ) = -B( JS, JSP1 )
709 Z( 4, 2 ) = -B( JSP1, JSP1 )
710 *
711 Z( 1, 3 ) = D( IS, IS )
712 Z( 2, 3 ) = ZERO
713 Z( 3, 3 ) = -E( JS, JS )
714 Z( 4, 3 ) = ZERO
715 *
716 Z( 1, 4 ) = ZERO
717 Z( 2, 4 ) = D( IS, IS )
718 Z( 3, 4 ) = -E( JS, JSP1 )
719 Z( 4, 4 ) = -E( JSP1, JSP1 )
720 *
721 * Set up right hand side(s)
722 *
723 RHS( 1 ) = C( IS, JS )
724 RHS( 2 ) = C( IS, JSP1 )
725 RHS( 3 ) = F( IS, JS )
726 RHS( 4 ) = F( IS, JSP1 )
727 *
728 * Solve Z' * x = RHS
729 *
730 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
731 IF( IERR.GT.0 )
732 $ INFO = IERR
733 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV, SCALOC )
734 IF( SCALOC.NE.ONE ) THEN
735 DO 140 K = 1, N
736 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
737 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
738 140 CONTINUE
739 SCALE = SCALE*SCALOC
740 END IF
741 *
742 * Unpack solution vector(s)
743 *
744 C( IS, JS ) = RHS( 1 )
745 C( IS, JSP1 ) = RHS( 2 )
746 F( IS, JS ) = RHS( 3 )
747 F( IS, JSP1 ) = RHS( 4 )
748 *
749 * Substitute R(I, J) and L(I, J) into remaining
750 * equation.
751 *
752 IF( J.GT.P+2 ) THEN
753 CALL DAXPY( JS-1, RHS( 1 ), B( 1, JS ), 1,
754 $ F( IS, 1 ), LDF )
755 CALL DAXPY( JS-1, RHS( 2 ), B( 1, JSP1 ), 1,
756 $ F( IS, 1 ), LDF )
757 CALL DAXPY( JS-1, RHS( 3 ), E( 1, JS ), 1,
758 $ F( IS, 1 ), LDF )
759 CALL DAXPY( JS-1, RHS( 4 ), E( 1, JSP1 ), 1,
760 $ F( IS, 1 ), LDF )
761 END IF
762 IF( I.LT.P ) THEN
763 CALL DGER( M-IE, NB, -ONE, A( IS, IE+1 ), LDA,
764 $ RHS( 1 ), 1, C( IE+1, JS ), LDC )
765 CALL DGER( M-IE, NB, -ONE, D( IS, IE+1 ), LDD,
766 $ RHS( 3 ), 1, C( IE+1, JS ), LDC )
767 END IF
768 *
769 ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.1 ) ) THEN
770 *
771 * Build a 4-by-4 system Z' * x = RHS
772 *
773 Z( 1, 1 ) = A( IS, IS )
774 Z( 2, 1 ) = A( IS, ISP1 )
775 Z( 3, 1 ) = -B( JS, JS )
776 Z( 4, 1 ) = ZERO
777 *
778 Z( 1, 2 ) = A( ISP1, IS )
779 Z( 2, 2 ) = A( ISP1, ISP1 )
780 Z( 3, 2 ) = ZERO
781 Z( 4, 2 ) = -B( JS, JS )
782 *
783 Z( 1, 3 ) = D( IS, IS )
784 Z( 2, 3 ) = D( IS, ISP1 )
785 Z( 3, 3 ) = -E( JS, JS )
786 Z( 4, 3 ) = ZERO
787 *
788 Z( 1, 4 ) = ZERO
789 Z( 2, 4 ) = D( ISP1, ISP1 )
790 Z( 3, 4 ) = ZERO
791 Z( 4, 4 ) = -E( JS, JS )
792 *
793 * Set up right hand side(s)
794 *
795 RHS( 1 ) = C( IS, JS )
796 RHS( 2 ) = C( ISP1, JS )
797 RHS( 3 ) = F( IS, JS )
798 RHS( 4 ) = F( ISP1, JS )
799 *
800 * Solve Z' * x = RHS
801 *
802 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
803 IF( IERR.GT.0 )
804 $ INFO = IERR
805 *
806 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV, SCALOC )
807 IF( SCALOC.NE.ONE ) THEN
808 DO 150 K = 1, N
809 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
810 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
811 150 CONTINUE
812 SCALE = SCALE*SCALOC
813 END IF
814 *
815 * Unpack solution vector(s)
816 *
817 C( IS, JS ) = RHS( 1 )
818 C( ISP1, JS ) = RHS( 2 )
819 F( IS, JS ) = RHS( 3 )
820 F( ISP1, JS ) = RHS( 4 )
821 *
822 * Substitute R(I, J) and L(I, J) into remaining
823 * equation.
824 *
825 IF( J.GT.P+2 ) THEN
826 CALL DGER( MB, JS-1, ONE, RHS( 1 ), 1, B( 1, JS ),
827 $ 1, F( IS, 1 ), LDF )
828 CALL DGER( MB, JS-1, ONE, RHS( 3 ), 1, E( 1, JS ),
829 $ 1, F( IS, 1 ), LDF )
830 END IF
831 IF( I.LT.P ) THEN
832 CALL DGEMV( 'T', MB, M-IE, -ONE, A( IS, IE+1 ),
833 $ LDA, RHS( 1 ), 1, ONE, C( IE+1, JS ),
834 $ 1 )
835 CALL DGEMV( 'T', MB, M-IE, -ONE, D( IS, IE+1 ),
836 $ LDD, RHS( 3 ), 1, ONE, C( IE+1, JS ),
837 $ 1 )
838 END IF
839 *
840 ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.2 ) ) THEN
841 *
842 * Build an 8-by-8 system Z' * x = RHS
843 *
844 CALL DCOPY( LDZ*LDZ, ZERO, 0, Z, 1 )
845 *
846 Z( 1, 1 ) = A( IS, IS )
847 Z( 2, 1 ) = A( IS, ISP1 )
848 Z( 5, 1 ) = -B( JS, JS )
849 Z( 7, 1 ) = -B( JSP1, JS )
850 *
851 Z( 1, 2 ) = A( ISP1, IS )
852 Z( 2, 2 ) = A( ISP1, ISP1 )
853 Z( 6, 2 ) = -B( JS, JS )
854 Z( 8, 2 ) = -B( JSP1, JS )
855 *
856 Z( 3, 3 ) = A( IS, IS )
857 Z( 4, 3 ) = A( IS, ISP1 )
858 Z( 5, 3 ) = -B( JS, JSP1 )
859 Z( 7, 3 ) = -B( JSP1, JSP1 )
860 *
861 Z( 3, 4 ) = A( ISP1, IS )
862 Z( 4, 4 ) = A( ISP1, ISP1 )
863 Z( 6, 4 ) = -B( JS, JSP1 )
864 Z( 8, 4 ) = -B( JSP1, JSP1 )
865 *
866 Z( 1, 5 ) = D( IS, IS )
867 Z( 2, 5 ) = D( IS, ISP1 )
868 Z( 5, 5 ) = -E( JS, JS )
869 *
870 Z( 2, 6 ) = D( ISP1, ISP1 )
871 Z( 6, 6 ) = -E( JS, JS )
872 *
873 Z( 3, 7 ) = D( IS, IS )
874 Z( 4, 7 ) = D( IS, ISP1 )
875 Z( 5, 7 ) = -E( JS, JSP1 )
876 Z( 7, 7 ) = -E( JSP1, JSP1 )
877 *
878 Z( 4, 8 ) = D( ISP1, ISP1 )
879 Z( 6, 8 ) = -E( JS, JSP1 )
880 Z( 8, 8 ) = -E( JSP1, JSP1 )
881 *
882 * Set up right hand side(s)
883 *
884 K = 1
885 II = MB*NB + 1
886 DO 160 JJ = 0, NB - 1
887 CALL DCOPY( MB, C( IS, JS+JJ ), 1, RHS( K ), 1 )
888 CALL DCOPY( MB, F( IS, JS+JJ ), 1, RHS( II ), 1 )
889 K = K + MB
890 II = II + MB
891 160 CONTINUE
892 *
893 *
894 * Solve Z' * x = RHS
895 *
896 CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
897 IF( IERR.GT.0 )
898 $ INFO = IERR
899 *
900 CALL DGESC2( ZDIM, Z, LDZ, RHS, IPIV, JPIV, SCALOC )
901 IF( SCALOC.NE.ONE ) THEN
902 DO 170 K = 1, N
903 CALL DSCAL( M, SCALOC, C( 1, K ), 1 )
904 CALL DSCAL( M, SCALOC, F( 1, K ), 1 )
905 170 CONTINUE
906 SCALE = SCALE*SCALOC
907 END IF
908 *
909 * Unpack solution vector(s)
910 *
911 K = 1
912 II = MB*NB + 1
913 DO 180 JJ = 0, NB - 1
914 CALL DCOPY( MB, RHS( K ), 1, C( IS, JS+JJ ), 1 )
915 CALL DCOPY( MB, RHS( II ), 1, F( IS, JS+JJ ), 1 )
916 K = K + MB
917 II = II + MB
918 180 CONTINUE
919 *
920 * Substitute R(I, J) and L(I, J) into remaining
921 * equation.
922 *
923 IF( J.GT.P+2 ) THEN
924 CALL DGEMM( 'N', 'T', MB, JS-1, NB, ONE,
925 $ C( IS, JS ), LDC, B( 1, JS ), LDB, ONE,
926 $ F( IS, 1 ), LDF )
927 CALL DGEMM( 'N', 'T', MB, JS-1, NB, ONE,
928 $ F( IS, JS ), LDF, E( 1, JS ), LDE, ONE,
929 $ F( IS, 1 ), LDF )
930 END IF
931 IF( I.LT.P ) THEN
932 CALL DGEMM( 'T', 'N', M-IE, NB, MB, -ONE,
933 $ A( IS, IE+1 ), LDA, C( IS, JS ), LDC,
934 $ ONE, C( IE+1, JS ), LDC )
935 CALL DGEMM( 'T', 'N', M-IE, NB, MB, -ONE,
936 $ D( IS, IE+1 ), LDD, F( IS, JS ), LDF,
937 $ ONE, C( IE+1, JS ), LDC )
938 END IF
939 *
940 END IF
941 *
942 190 CONTINUE
943 200 CONTINUE
944 *
945 END IF
946 RETURN
947 *
948 * End of DTGSY2
949 *
950 END