LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
zlatrs.f
Go to the documentation of this file.
1*> \brief \b ZLATRS solves a triangular system of equations with the scale factor set to prevent overflow.
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8*> \htmlonly
9*> Download ZLATRS + dependencies
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlatrs.f">
11*> [TGZ]</a>
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlatrs.f">
13*> [ZIP]</a>
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrs.f">
15*> [TXT]</a>
16*> \endhtmlonly
17*
18* Definition:
19* ===========
20*
21* SUBROUTINE ZLATRS( UPLO, TRANS, DIAG, NORMIN, N, A, LDA, X, SCALE,
22* CNORM, INFO )
23*
24* .. Scalar Arguments ..
25* CHARACTER DIAG, NORMIN, TRANS, UPLO
26* INTEGER INFO, LDA, N
27* DOUBLE PRECISION SCALE
28* ..
29* .. Array Arguments ..
30* DOUBLE PRECISION CNORM( * )
31* COMPLEX*16 A( LDA, * ), X( * )
32* ..
33*
34*
35*> \par Purpose:
36* =============
37*>
38*> \verbatim
39*>
40*> ZLATRS solves one of the triangular systems
41*>
42*> A * x = s*b, A**T * x = s*b, or A**H * x = s*b,
43*>
44*> with scaling to prevent overflow. Here A is an upper or lower
45*> triangular matrix, A**T denotes the transpose of A, A**H denotes the
46*> conjugate transpose of A, x and b are n-element vectors, and s is a
47*> scaling factor, usually less than or equal to 1, chosen so that the
48*> components of x will be less than the overflow threshold. If the
49*> unscaled problem will not cause overflow, the Level 2 BLAS routine
50*> ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j),
51*> then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
52*> \endverbatim
53*
54* Arguments:
55* ==========
56*
57*> \param[in] UPLO
58*> \verbatim
59*> UPLO is CHARACTER*1
60*> Specifies whether the matrix A is upper or lower triangular.
61*> = 'U': Upper triangular
62*> = 'L': Lower triangular
63*> \endverbatim
64*>
65*> \param[in] TRANS
66*> \verbatim
67*> TRANS is CHARACTER*1
68*> Specifies the operation applied to A.
69*> = 'N': Solve A * x = s*b (No transpose)
70*> = 'T': Solve A**T * x = s*b (Transpose)
71*> = 'C': Solve A**H * x = s*b (Conjugate transpose)
72*> \endverbatim
73*>
74*> \param[in] DIAG
75*> \verbatim
76*> DIAG is CHARACTER*1
77*> Specifies whether or not the matrix A is unit triangular.
78*> = 'N': Non-unit triangular
79*> = 'U': Unit triangular
80*> \endverbatim
81*>
82*> \param[in] NORMIN
83*> \verbatim
84*> NORMIN is CHARACTER*1
85*> Specifies whether CNORM has been set or not.
86*> = 'Y': CNORM contains the column norms on entry
87*> = 'N': CNORM is not set on entry. On exit, the norms will
88*> be computed and stored in CNORM.
89*> \endverbatim
90*>
91*> \param[in] N
92*> \verbatim
93*> N is INTEGER
94*> The order of the matrix A. N >= 0.
95*> \endverbatim
96*>
97*> \param[in] A
98*> \verbatim
99*> A is COMPLEX*16 array, dimension (LDA,N)
100*> The triangular matrix A. If UPLO = 'U', the leading n by n
101*> upper triangular part of the array A contains the upper
102*> triangular matrix, and the strictly lower triangular part of
103*> A is not referenced. If UPLO = 'L', the leading n by n lower
104*> triangular part of the array A contains the lower triangular
105*> matrix, and the strictly upper triangular part of A is not
106*> referenced. If DIAG = 'U', the diagonal elements of A are
107*> also not referenced and are assumed to be 1.
108*> \endverbatim
109*>
110*> \param[in] LDA
111*> \verbatim
112*> LDA is INTEGER
113*> The leading dimension of the array A. LDA >= max (1,N).
114*> \endverbatim
115*>
116*> \param[in,out] X
117*> \verbatim
118*> X is COMPLEX*16 array, dimension (N)
119*> On entry, the right hand side b of the triangular system.
120*> On exit, X is overwritten by the solution vector x.
121*> \endverbatim
122*>
123*> \param[out] SCALE
124*> \verbatim
125*> SCALE is DOUBLE PRECISION
126*> The scaling factor s for the triangular system
127*> A * x = s*b, A**T * x = s*b, or A**H * x = s*b.
128*> If SCALE = 0, the matrix A is singular or badly scaled, and
129*> the vector x is an exact or approximate solution to A*x = 0.
130*> \endverbatim
131*>
132*> \param[in,out] CNORM
133*> \verbatim
134*> CNORM is DOUBLE PRECISION array, dimension (N)
135*>
136*> If NORMIN = 'Y', CNORM is an input argument and CNORM(j)
137*> contains the norm of the off-diagonal part of the j-th column
138*> of A. If TRANS = 'N', CNORM(j) must be greater than or equal
139*> to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)
140*> must be greater than or equal to the 1-norm.
141*>
142*> If NORMIN = 'N', CNORM is an output argument and CNORM(j)
143*> returns the 1-norm of the offdiagonal part of the j-th column
144*> of A.
145*> \endverbatim
146*>
147*> \param[out] INFO
148*> \verbatim
149*> INFO is INTEGER
150*> = 0: successful exit
151*> < 0: if INFO = -k, the k-th argument had an illegal value
152*> \endverbatim
153*
154* Authors:
155* ========
156*
157*> \author Univ. of Tennessee
158*> \author Univ. of California Berkeley
159*> \author Univ. of Colorado Denver
160*> \author NAG Ltd.
161*
162*> \ingroup latrs
163*
164*> \par Further Details:
165* =====================
166*>
167*> \verbatim
168*>
169*> A rough bound on x is computed; if that is less than overflow, ZTRSV
170*> is called, otherwise, specific code is used which checks for possible
171*> overflow or divide-by-zero at every operation.
172*>
173*> A columnwise scheme is used for solving A*x = b. The basic algorithm
174*> if A is lower triangular is
175*>
176*> x[1:n] := b[1:n]
177*> for j = 1, ..., n
178*> x(j) := x(j) / A(j,j)
179*> x[j+1:n] := x[j+1:n] - x(j) * A[j+1:n,j]
180*> end
181*>
182*> Define bounds on the components of x after j iterations of the loop:
183*> M(j) = bound on x[1:j]
184*> G(j) = bound on x[j+1:n]
185*> Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.
186*>
187*> Then for iteration j+1 we have
188*> M(j+1) <= G(j) / | A(j+1,j+1) |
189*> G(j+1) <= G(j) + M(j+1) * | A[j+2:n,j+1] |
190*> <= G(j) ( 1 + CNORM(j+1) / | A(j+1,j+1) | )
191*>
192*> where CNORM(j+1) is greater than or equal to the infinity-norm of
193*> column j+1 of A, not counting the diagonal. Hence
194*>
195*> G(j) <= G(0) product ( 1 + CNORM(i) / | A(i,i) | )
196*> 1<=i<=j
197*> and
198*>
199*> |x(j)| <= ( G(0) / |A(j,j)| ) product ( 1 + CNORM(i) / |A(i,i)| )
200*> 1<=i< j
201*>
202*> Since |x(j)| <= M(j), we use the Level 2 BLAS routine ZTRSV if the
203*> reciprocal of the largest M(j), j=1,..,n, is larger than
204*> max(underflow, 1/overflow).
205*>
206*> The bound on x(j) is also used to determine when a step in the
207*> columnwise method can be performed without fear of overflow. If
208*> the computed bound is greater than a large constant, x is scaled to
209*> prevent overflow, but if the bound overflows, x is set to 0, x(j) to
210*> 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
211*>
212*> Similarly, a row-wise scheme is used to solve A**T *x = b or
213*> A**H *x = b. The basic algorithm for A upper triangular is
214*>
215*> for j = 1, ..., n
216*> x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
217*> end
218*>
219*> We simultaneously compute two bounds
220*> G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
221*> M(j) = bound on x(i), 1<=i<=j
222*>
223*> The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
224*> add the constraint G(j) >= G(j-1) and M(j) >= M(j-1) for j >= 1.
225*> Then the bound on x(j) is
226*>
227*> M(j) <= M(j-1) * ( 1 + CNORM(j) ) / | A(j,j) |
228*>
229*> <= M(0) * product ( ( 1 + CNORM(i) ) / |A(i,i)| )
230*> 1<=i<=j
231*>
232*> and we can safely call ZTRSV if 1/M(n) and 1/G(n) are both greater
233*> than max(underflow, 1/overflow).
234*> \endverbatim
235*>
236* =====================================================================
237 SUBROUTINE zlatrs( UPLO, TRANS, DIAG, NORMIN, N, A, LDA, X, SCALE,
238 $ CNORM, INFO )
239*
240* -- LAPACK auxiliary routine --
241* -- LAPACK is a software package provided by Univ. of Tennessee, --
242* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
243*
244* .. Scalar Arguments ..
245 CHARACTER DIAG, NORMIN, TRANS, UPLO
246 INTEGER INFO, LDA, N
247 DOUBLE PRECISION SCALE
248* ..
249* .. Array Arguments ..
250 DOUBLE PRECISION CNORM( * )
251 COMPLEX*16 A( LDA, * ), X( * )
252* ..
253*
254* =====================================================================
255*
256* .. Parameters ..
257 DOUBLE PRECISION ZERO, HALF, ONE, TWO
258 parameter( zero = 0.0d+0, half = 0.5d+0, one = 1.0d+0,
259 $ two = 2.0d+0 )
260* ..
261* .. Local Scalars ..
262 LOGICAL NOTRAN, NOUNIT, UPPER
263 INTEGER I, IMAX, J, JFIRST, JINC, JLAST
264 DOUBLE PRECISION BIGNUM, GROW, REC, SMLNUM, TJJ, TMAX, TSCAL,
265 $ xbnd, xj, xmax
266 COMPLEX*16 CSUMJ, TJJS, USCAL, ZDUM
267* ..
268* .. External Functions ..
269 LOGICAL LSAME
270 INTEGER IDAMAX, IZAMAX
271 DOUBLE PRECISION DLAMCH, DZASUM
272 COMPLEX*16 ZDOTC, ZDOTU, ZLADIV
273 EXTERNAL lsame, idamax, izamax, dlamch, dzasum, zdotc,
274 $ zdotu, zladiv
275* ..
276* .. External Subroutines ..
277 EXTERNAL dscal, xerbla, zaxpy, zdscal, ztrsv
278* ..
279* .. Intrinsic Functions ..
280 INTRINSIC abs, dble, dcmplx, dconjg, dimag, max, min
281* ..
282* .. Statement Functions ..
283 DOUBLE PRECISION CABS1, CABS2
284* ..
285* .. Statement Function definitions ..
286 cabs1( zdum ) = abs( dble( zdum ) ) + abs( dimag( zdum ) )
287 cabs2( zdum ) = abs( dble( zdum ) / 2.d0 ) +
288 $ abs( dimag( zdum ) / 2.d0 )
289* ..
290* .. Executable Statements ..
291*
292 info = 0
293 upper = lsame( uplo, 'U' )
294 notran = lsame( trans, 'N' )
295 nounit = lsame( diag, 'N' )
296*
297* Test the input parameters.
298*
299 IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
300 info = -1
301 ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'T' ) .AND. .NOT.
302 $ lsame( trans, 'C' ) ) THEN
303 info = -2
304 ELSE IF( .NOT.nounit .AND. .NOT.lsame( diag, 'U' ) ) THEN
305 info = -3
306 ELSE IF( .NOT.lsame( normin, 'Y' ) .AND. .NOT.
307 $ lsame( normin, 'N' ) ) THEN
308 info = -4
309 ELSE IF( n.LT.0 ) THEN
310 info = -5
311 ELSE IF( lda.LT.max( 1, n ) ) THEN
312 info = -7
313 END IF
314 IF( info.NE.0 ) THEN
315 CALL xerbla( 'ZLATRS', -info )
316 RETURN
317 END IF
318*
319* Quick return if possible
320*
321 scale = one
322 IF( n.EQ.0 )
323 $ RETURN
324*
325* Determine machine dependent parameters to control overflow.
326*
327 smlnum = dlamch( 'Safe minimum' ) / dlamch( 'Precision' )
328 bignum = one / smlnum
329*
330 IF( lsame( normin, 'N' ) ) THEN
331*
332* Compute the 1-norm of each column, not including the diagonal.
333*
334 IF( upper ) THEN
335*
336* A is upper triangular.
337*
338 DO 10 j = 1, n
339 cnorm( j ) = dzasum( j-1, a( 1, j ), 1 )
340 10 CONTINUE
341 ELSE
342*
343* A is lower triangular.
344*
345 DO 20 j = 1, n - 1
346 cnorm( j ) = dzasum( n-j, a( j+1, j ), 1 )
347 20 CONTINUE
348 cnorm( n ) = zero
349 END IF
350 END IF
351*
352* Scale the column norms by TSCAL if the maximum element in CNORM is
353* greater than BIGNUM/2.
354*
355 imax = idamax( n, cnorm, 1 )
356 tmax = cnorm( imax )
357 IF( tmax.LE.bignum*half ) THEN
358 tscal = one
359 ELSE
360*
361* Avoid NaN generation if entries in CNORM exceed the
362* overflow threshold
363*
364 IF ( tmax.LE.dlamch('Overflow') ) THEN
365* Case 1: All entries in CNORM are valid floating-point numbers
366 tscal = half / ( smlnum*tmax )
367 CALL dscal( n, tscal, cnorm, 1 )
368 ELSE
369* Case 2: At least one column norm of A cannot be
370* represented as a floating-point number. Find the
371* maximum offdiagonal absolute value
372* max( |Re(A(I,J))|, |Im(A(I,J)| ). If this entry is
373* not +/- Infinity, use this value as TSCAL.
374 tmax = zero
375 IF( upper ) THEN
376*
377* A is upper triangular.
378*
379 DO j = 2, n
380 DO i = 1, j - 1
381 tmax = max( tmax, abs( dble( a( i, j ) ) ),
382 $ abs( dimag(a( i, j ) ) ) )
383 END DO
384 END DO
385 ELSE
386*
387* A is lower triangular.
388*
389 DO j = 1, n - 1
390 DO i = j + 1, n
391 tmax = max( tmax, abs( dble( a( i, j ) ) ),
392 $ abs( dimag(a( i, j ) ) ) )
393 END DO
394 END DO
395 END IF
396*
397 IF( tmax.LE.dlamch('Overflow') ) THEN
398 tscal = one / ( smlnum*tmax )
399 DO j = 1, n
400 IF( cnorm( j ).LE.dlamch('Overflow') ) THEN
401 cnorm( j ) = cnorm( j )*tscal
402 ELSE
403* Recompute the 1-norm of each column without
404* introducing Infinity in the summation.
405 tscal = two * tscal
406 cnorm( j ) = zero
407 IF( upper ) THEN
408 DO i = 1, j - 1
409 cnorm( j ) = cnorm( j ) +
410 $ tscal * cabs2( a( i, j ) )
411 END DO
412 ELSE
413 DO i = j + 1, n
414 cnorm( j ) = cnorm( j ) +
415 $ tscal * cabs2( a( i, j ) )
416 END DO
417 END IF
418 tscal = tscal * half
419 END IF
420 END DO
421 ELSE
422* At least one entry of A is not a valid floating-point
423* entry. Rely on TRSV to propagate Inf and NaN.
424 CALL ztrsv( uplo, trans, diag, n, a, lda, x, 1 )
425 RETURN
426 END IF
427 END IF
428 END IF
429*
430* Compute a bound on the computed solution vector to see if the
431* Level 2 BLAS routine ZTRSV can be used.
432*
433 xmax = zero
434 DO 30 j = 1, n
435 xmax = max( xmax, cabs2( x( j ) ) )
436 30 CONTINUE
437 xbnd = xmax
438*
439 IF( notran ) THEN
440*
441* Compute the growth in A * x = b.
442*
443 IF( upper ) THEN
444 jfirst = n
445 jlast = 1
446 jinc = -1
447 ELSE
448 jfirst = 1
449 jlast = n
450 jinc = 1
451 END IF
452*
453 IF( tscal.NE.one ) THEN
454 grow = zero
455 GO TO 60
456 END IF
457*
458 IF( nounit ) THEN
459*
460* A is non-unit triangular.
461*
462* Compute GROW = 1/G(j) and XBND = 1/M(j).
463* Initially, G(0) = max{x(i), i=1,...,n}.
464*
465 grow = half / max( xbnd, smlnum )
466 xbnd = grow
467 DO 40 j = jfirst, jlast, jinc
468*
469* Exit the loop if the growth factor is too small.
470*
471 IF( grow.LE.smlnum )
472 $ GO TO 60
473*
474 tjjs = a( j, j )
475 tjj = cabs1( tjjs )
476*
477 IF( tjj.GE.smlnum ) THEN
478*
479* M(j) = G(j-1) / abs(A(j,j))
480*
481 xbnd = min( xbnd, min( one, tjj )*grow )
482 ELSE
483*
484* M(j) could overflow, set XBND to 0.
485*
486 xbnd = zero
487 END IF
488*
489 IF( tjj+cnorm( j ).GE.smlnum ) THEN
490*
491* G(j) = G(j-1)*( 1 + CNORM(j) / abs(A(j,j)) )
492*
493 grow = grow*( tjj / ( tjj+cnorm( j ) ) )
494 ELSE
495*
496* G(j) could overflow, set GROW to 0.
497*
498 grow = zero
499 END IF
500 40 CONTINUE
501 grow = xbnd
502 ELSE
503*
504* A is unit triangular.
505*
506* Compute GROW = 1/G(j), where G(0) = max{x(i), i=1,...,n}.
507*
508 grow = min( one, half / max( xbnd, smlnum ) )
509 DO 50 j = jfirst, jlast, jinc
510*
511* Exit the loop if the growth factor is too small.
512*
513 IF( grow.LE.smlnum )
514 $ GO TO 60
515*
516* G(j) = G(j-1)*( 1 + CNORM(j) )
517*
518 grow = grow*( one / ( one+cnorm( j ) ) )
519 50 CONTINUE
520 END IF
521 60 CONTINUE
522*
523 ELSE
524*
525* Compute the growth in A**T * x = b or A**H * x = b.
526*
527 IF( upper ) THEN
528 jfirst = 1
529 jlast = n
530 jinc = 1
531 ELSE
532 jfirst = n
533 jlast = 1
534 jinc = -1
535 END IF
536*
537 IF( tscal.NE.one ) THEN
538 grow = zero
539 GO TO 90
540 END IF
541*
542 IF( nounit ) THEN
543*
544* A is non-unit triangular.
545*
546* Compute GROW = 1/G(j) and XBND = 1/M(j).
547* Initially, M(0) = max{x(i), i=1,...,n}.
548*
549 grow = half / max( xbnd, smlnum )
550 xbnd = grow
551 DO 70 j = jfirst, jlast, jinc
552*
553* Exit the loop if the growth factor is too small.
554*
555 IF( grow.LE.smlnum )
556 $ GO TO 90
557*
558* G(j) = max( G(j-1), M(j-1)*( 1 + CNORM(j) ) )
559*
560 xj = one + cnorm( j )
561 grow = min( grow, xbnd / xj )
562*
563 tjjs = a( j, j )
564 tjj = cabs1( tjjs )
565*
566 IF( tjj.GE.smlnum ) THEN
567*
568* M(j) = M(j-1)*( 1 + CNORM(j) ) / abs(A(j,j))
569*
570 IF( xj.GT.tjj )
571 $ xbnd = xbnd*( tjj / xj )
572 ELSE
573*
574* M(j) could overflow, set XBND to 0.
575*
576 xbnd = zero
577 END IF
578 70 CONTINUE
579 grow = min( grow, xbnd )
580 ELSE
581*
582* A is unit triangular.
583*
584* Compute GROW = 1/G(j), where G(0) = max{x(i), i=1,...,n}.
585*
586 grow = min( one, half / max( xbnd, smlnum ) )
587 DO 80 j = jfirst, jlast, jinc
588*
589* Exit the loop if the growth factor is too small.
590*
591 IF( grow.LE.smlnum )
592 $ GO TO 90
593*
594* G(j) = ( 1 + CNORM(j) )*G(j-1)
595*
596 xj = one + cnorm( j )
597 grow = grow / xj
598 80 CONTINUE
599 END IF
600 90 CONTINUE
601 END IF
602*
603 IF( ( grow*tscal ).GT.smlnum ) THEN
604*
605* Use the Level 2 BLAS solve if the reciprocal of the bound on
606* elements of X is not too small.
607*
608 CALL ztrsv( uplo, trans, diag, n, a, lda, x, 1 )
609 ELSE
610*
611* Use a Level 1 BLAS solve, scaling intermediate results.
612*
613 IF( xmax.GT.bignum*half ) THEN
614*
615* Scale X so that its components are less than or equal to
616* BIGNUM in absolute value.
617*
618 scale = ( bignum*half ) / xmax
619 CALL zdscal( n, scale, x, 1 )
620 xmax = bignum
621 ELSE
622 xmax = xmax*two
623 END IF
624*
625 IF( notran ) THEN
626*
627* Solve A * x = b
628*
629 DO 120 j = jfirst, jlast, jinc
630*
631* Compute x(j) = b(j) / A(j,j), scaling x if necessary.
632*
633 xj = cabs1( x( j ) )
634 IF( nounit ) THEN
635 tjjs = a( j, j )*tscal
636 ELSE
637 tjjs = tscal
638 IF( tscal.EQ.one )
639 $ GO TO 110
640 END IF
641 tjj = cabs1( tjjs )
642 IF( tjj.GT.smlnum ) THEN
643*
644* abs(A(j,j)) > SMLNUM:
645*
646 IF( tjj.LT.one ) THEN
647 IF( xj.GT.tjj*bignum ) THEN
648*
649* Scale x by 1/b(j).
650*
651 rec = one / xj
652 CALL zdscal( n, rec, x, 1 )
653 scale = scale*rec
654 xmax = xmax*rec
655 END IF
656 END IF
657 x( j ) = zladiv( x( j ), tjjs )
658 xj = cabs1( x( j ) )
659 ELSE IF( tjj.GT.zero ) THEN
660*
661* 0 < abs(A(j,j)) <= SMLNUM:
662*
663 IF( xj.GT.tjj*bignum ) THEN
664*
665* Scale x by (1/abs(x(j)))*abs(A(j,j))*BIGNUM
666* to avoid overflow when dividing by A(j,j).
667*
668 rec = ( tjj*bignum ) / xj
669 IF( cnorm( j ).GT.one ) THEN
670*
671* Scale by 1/CNORM(j) to avoid overflow when
672* multiplying x(j) times column j.
673*
674 rec = rec / cnorm( j )
675 END IF
676 CALL zdscal( n, rec, x, 1 )
677 scale = scale*rec
678 xmax = xmax*rec
679 END IF
680 x( j ) = zladiv( x( j ), tjjs )
681 xj = cabs1( x( j ) )
682 ELSE
683*
684* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
685* scale = 0, and compute a solution to A*x = 0.
686*
687 DO 100 i = 1, n
688 x( i ) = zero
689 100 CONTINUE
690 x( j ) = one
691 xj = one
692 scale = zero
693 xmax = zero
694 END IF
695 110 CONTINUE
696*
697* Scale x if necessary to avoid overflow when adding a
698* multiple of column j of A.
699*
700 IF( xj.GT.one ) THEN
701 rec = one / xj
702 IF( cnorm( j ).GT.( bignum-xmax )*rec ) THEN
703*
704* Scale x by 1/(2*abs(x(j))).
705*
706 rec = rec*half
707 CALL zdscal( n, rec, x, 1 )
708 scale = scale*rec
709 END IF
710 ELSE IF( xj*cnorm( j ).GT.( bignum-xmax ) ) THEN
711*
712* Scale x by 1/2.
713*
714 CALL zdscal( n, half, x, 1 )
715 scale = scale*half
716 END IF
717*
718 IF( upper ) THEN
719 IF( j.GT.1 ) THEN
720*
721* Compute the update
722* x(1:j-1) := x(1:j-1) - x(j) * A(1:j-1,j)
723*
724 CALL zaxpy( j-1, -x( j )*tscal, a( 1, j ), 1, x,
725 $ 1 )
726 i = izamax( j-1, x, 1 )
727 xmax = cabs1( x( i ) )
728 END IF
729 ELSE
730 IF( j.LT.n ) THEN
731*
732* Compute the update
733* x(j+1:n) := x(j+1:n) - x(j) * A(j+1:n,j)
734*
735 CALL zaxpy( n-j, -x( j )*tscal, a( j+1, j ), 1,
736 $ x( j+1 ), 1 )
737 i = j + izamax( n-j, x( j+1 ), 1 )
738 xmax = cabs1( x( i ) )
739 END IF
740 END IF
741 120 CONTINUE
742*
743 ELSE IF( lsame( trans, 'T' ) ) THEN
744*
745* Solve A**T * x = b
746*
747 DO 170 j = jfirst, jlast, jinc
748*
749* Compute x(j) = b(j) - sum A(k,j)*x(k).
750* k<>j
751*
752 xj = cabs1( x( j ) )
753 uscal = tscal
754 rec = one / max( xmax, one )
755 IF( cnorm( j ).GT.( bignum-xj )*rec ) THEN
756*
757* If x(j) could overflow, scale x by 1/(2*XMAX).
758*
759 rec = rec*half
760 IF( nounit ) THEN
761 tjjs = a( j, j )*tscal
762 ELSE
763 tjjs = tscal
764 END IF
765 tjj = cabs1( tjjs )
766 IF( tjj.GT.one ) THEN
767*
768* Divide by A(j,j) when scaling x if A(j,j) > 1.
769*
770 rec = min( one, rec*tjj )
771 uscal = zladiv( uscal, tjjs )
772 END IF
773 IF( rec.LT.one ) THEN
774 CALL zdscal( n, rec, x, 1 )
775 scale = scale*rec
776 xmax = xmax*rec
777 END IF
778 END IF
779*
780 csumj = zero
781 IF( uscal.EQ.dcmplx( one ) ) THEN
782*
783* If the scaling needed for A in the dot product is 1,
784* call ZDOTU to perform the dot product.
785*
786 IF( upper ) THEN
787 csumj = zdotu( j-1, a( 1, j ), 1, x, 1 )
788 ELSE IF( j.LT.n ) THEN
789 csumj = zdotu( n-j, a( j+1, j ), 1, x( j+1 ), 1 )
790 END IF
791 ELSE
792*
793* Otherwise, use in-line code for the dot product.
794*
795 IF( upper ) THEN
796 DO 130 i = 1, j - 1
797 csumj = csumj + ( a( i, j )*uscal )*x( i )
798 130 CONTINUE
799 ELSE IF( j.LT.n ) THEN
800 DO 140 i = j + 1, n
801 csumj = csumj + ( a( i, j )*uscal )*x( i )
802 140 CONTINUE
803 END IF
804 END IF
805*
806 IF( uscal.EQ.dcmplx( tscal ) ) THEN
807*
808* Compute x(j) := ( x(j) - CSUMJ ) / A(j,j) if 1/A(j,j)
809* was not used to scale the dotproduct.
810*
811 x( j ) = x( j ) - csumj
812 xj = cabs1( x( j ) )
813 IF( nounit ) THEN
814 tjjs = a( j, j )*tscal
815 ELSE
816 tjjs = tscal
817 IF( tscal.EQ.one )
818 $ GO TO 160
819 END IF
820*
821* Compute x(j) = x(j) / A(j,j), scaling if necessary.
822*
823 tjj = cabs1( tjjs )
824 IF( tjj.GT.smlnum ) THEN
825*
826* abs(A(j,j)) > SMLNUM:
827*
828 IF( tjj.LT.one ) THEN
829 IF( xj.GT.tjj*bignum ) THEN
830*
831* Scale X by 1/abs(x(j)).
832*
833 rec = one / xj
834 CALL zdscal( n, rec, x, 1 )
835 scale = scale*rec
836 xmax = xmax*rec
837 END IF
838 END IF
839 x( j ) = zladiv( x( j ), tjjs )
840 ELSE IF( tjj.GT.zero ) THEN
841*
842* 0 < abs(A(j,j)) <= SMLNUM:
843*
844 IF( xj.GT.tjj*bignum ) THEN
845*
846* Scale x by (1/abs(x(j)))*abs(A(j,j))*BIGNUM.
847*
848 rec = ( tjj*bignum ) / xj
849 CALL zdscal( n, rec, x, 1 )
850 scale = scale*rec
851 xmax = xmax*rec
852 END IF
853 x( j ) = zladiv( x( j ), tjjs )
854 ELSE
855*
856* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
857* scale = 0 and compute a solution to A**T *x = 0.
858*
859 DO 150 i = 1, n
860 x( i ) = zero
861 150 CONTINUE
862 x( j ) = one
863 scale = zero
864 xmax = zero
865 END IF
866 160 CONTINUE
867 ELSE
868*
869* Compute x(j) := x(j) / A(j,j) - CSUMJ if the dot
870* product has already been divided by 1/A(j,j).
871*
872 x( j ) = zladiv( x( j ), tjjs ) - csumj
873 END IF
874 xmax = max( xmax, cabs1( x( j ) ) )
875 170 CONTINUE
876*
877 ELSE
878*
879* Solve A**H * x = b
880*
881 DO 220 j = jfirst, jlast, jinc
882*
883* Compute x(j) = b(j) - sum A(k,j)*x(k).
884* k<>j
885*
886 xj = cabs1( x( j ) )
887 uscal = tscal
888 rec = one / max( xmax, one )
889 IF( cnorm( j ).GT.( bignum-xj )*rec ) THEN
890*
891* If x(j) could overflow, scale x by 1/(2*XMAX).
892*
893 rec = rec*half
894 IF( nounit ) THEN
895 tjjs = dconjg( a( j, j ) )*tscal
896 ELSE
897 tjjs = tscal
898 END IF
899 tjj = cabs1( tjjs )
900 IF( tjj.GT.one ) THEN
901*
902* Divide by A(j,j) when scaling x if A(j,j) > 1.
903*
904 rec = min( one, rec*tjj )
905 uscal = zladiv( uscal, tjjs )
906 END IF
907 IF( rec.LT.one ) THEN
908 CALL zdscal( n, rec, x, 1 )
909 scale = scale*rec
910 xmax = xmax*rec
911 END IF
912 END IF
913*
914 csumj = zero
915 IF( uscal.EQ.dcmplx( one ) ) THEN
916*
917* If the scaling needed for A in the dot product is 1,
918* call ZDOTC to perform the dot product.
919*
920 IF( upper ) THEN
921 csumj = zdotc( j-1, a( 1, j ), 1, x, 1 )
922 ELSE IF( j.LT.n ) THEN
923 csumj = zdotc( n-j, a( j+1, j ), 1, x( j+1 ), 1 )
924 END IF
925 ELSE
926*
927* Otherwise, use in-line code for the dot product.
928*
929 IF( upper ) THEN
930 DO 180 i = 1, j - 1
931 csumj = csumj + ( dconjg( a( i, j ) )*uscal )*
932 $ x( i )
933 180 CONTINUE
934 ELSE IF( j.LT.n ) THEN
935 DO 190 i = j + 1, n
936 csumj = csumj + ( dconjg( a( i, j ) )*uscal )*
937 $ x( i )
938 190 CONTINUE
939 END IF
940 END IF
941*
942 IF( uscal.EQ.dcmplx( tscal ) ) THEN
943*
944* Compute x(j) := ( x(j) - CSUMJ ) / A(j,j) if 1/A(j,j)
945* was not used to scale the dotproduct.
946*
947 x( j ) = x( j ) - csumj
948 xj = cabs1( x( j ) )
949 IF( nounit ) THEN
950 tjjs = dconjg( a( j, j ) )*tscal
951 ELSE
952 tjjs = tscal
953 IF( tscal.EQ.one )
954 $ GO TO 210
955 END IF
956*
957* Compute x(j) = x(j) / A(j,j), scaling if necessary.
958*
959 tjj = cabs1( tjjs )
960 IF( tjj.GT.smlnum ) THEN
961*
962* abs(A(j,j)) > SMLNUM:
963*
964 IF( tjj.LT.one ) THEN
965 IF( xj.GT.tjj*bignum ) THEN
966*
967* Scale X by 1/abs(x(j)).
968*
969 rec = one / xj
970 CALL zdscal( n, rec, x, 1 )
971 scale = scale*rec
972 xmax = xmax*rec
973 END IF
974 END IF
975 x( j ) = zladiv( x( j ), tjjs )
976 ELSE IF( tjj.GT.zero ) THEN
977*
978* 0 < abs(A(j,j)) <= SMLNUM:
979*
980 IF( xj.GT.tjj*bignum ) THEN
981*
982* Scale x by (1/abs(x(j)))*abs(A(j,j))*BIGNUM.
983*
984 rec = ( tjj*bignum ) / xj
985 CALL zdscal( n, rec, x, 1 )
986 scale = scale*rec
987 xmax = xmax*rec
988 END IF
989 x( j ) = zladiv( x( j ), tjjs )
990 ELSE
991*
992* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
993* scale = 0 and compute a solution to A**H *x = 0.
994*
995 DO 200 i = 1, n
996 x( i ) = zero
997 200 CONTINUE
998 x( j ) = one
999 scale = zero
1000 xmax = zero
1001 END IF
1002 210 CONTINUE
1003 ELSE
1004*
1005* Compute x(j) := x(j) / A(j,j) - CSUMJ if the dot
1006* product has already been divided by 1/A(j,j).
1007*
1008 x( j ) = zladiv( x( j ), tjjs ) - csumj
1009 END IF
1010 xmax = max( xmax, cabs1( x( j ) ) )
1011 220 CONTINUE
1012 END IF
1013 scale = scale / tscal
1014 END IF
1015*
1016* Scale the column norms by 1/TSCAL for return.
1017*
1018 IF( tscal.NE.one ) THEN
1019 CALL dscal( n, one / tscal, cnorm, 1 )
1020 END IF
1021*
1022 RETURN
1023*
1024* End of ZLATRS
1025*
1026 END
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
zaxpy
subroutine zaxpy(n, za, zx, incx, zy, incy)
ZAXPY
Definition zaxpy.f:88
zlatrs
subroutine zlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
ZLATRS solves a triangular system of equations with the scale factor set to prevent overflow.
Definition zlatrs.f:239
dscal
subroutine dscal(n, da, dx, incx)
DSCAL
Definition dscal.f:79
zdscal
subroutine zdscal(n, da, zx, incx)
ZDSCAL
Definition zdscal.f:78
ztrsv
subroutine ztrsv(uplo, trans, diag, n, a, lda, x, incx)
ZTRSV
Definition ztrsv.f:149