OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
csteqr2.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine csteqr2 (compz, n, d, e, z, ldz, nr, work, info)

Function/Subroutine Documentation

◆ csteqr2()

subroutine csteqr2 ( character compz,
integer n,
real, dimension( * ) d,
real, dimension( * ) e,
complex, dimension( ldz, * ) z,
integer ldz,
integer nr,
real, dimension( * ) work,
integer info )

Definition at line 1 of file csteqr2.f.

2*
3* -- ScaLAPACK routine (version 1.7) --
4* Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
5* Courant Institute, Argonne National Lab, and Rice University
6* November 15, 1997
7*
8* .. Scalar Arguments ..
9 CHARACTER COMPZ
10 INTEGER INFO, LDZ, N, NR
11* ..
12* .. Array Arguments ..
13 REAL D( * ), E( * ), WORK( * )
14 COMPLEX Z( LDZ, * )
15* ..
16*
17* Purpose
18* =======
19*
20* CSTEQR2 is a modified version of LAPACK routine CSTEQR.
21* CSTEQR2 computes all eigenvalues and, optionally, eigenvectors of a
22* symmetric tridiagonal matrix using the implicit QL or QR method.
23* CSTEQR2 is modified from CSTEQR to allow each ScaLAPACK process
24* running CSTEQR2 to perform updates on a distributed matrix Q.
25* Proper usage of CSTEQR2 can be gleaned from
26* examination of ScaLAPACK's * PCHEEV.
27* CSTEQR2 incorporates changes attributed to Greg Henry.
28*
29* Arguments
30* =========
31*
32* COMPZ (input) CHARACTER*1
33* = 'N': Compute eigenvalues only.
34* = 'I': Compute eigenvalues and eigenvectors of the
35* tridiagonal matrix. Z must be initialized to the
36* identity matrix by PCLASET or CLASET prior
37* to entering this subroutine.
38*
39* N (input) INTEGER
40* The order of the matrix. N >= 0.
41*
42* D (input/output) REAL array, dimension (N)
43* On entry, the diagonal elements of the tridiagonal matrix.
44* On exit, if INFO = 0, the eigenvalues in ascending order.
45*
46* E (input/output) REAL array, dimension (N-1)
47* On entry, the (n-1) subdiagonal elements of the tridiagonal
48* matrix.
49* On exit, E has been destroyed.
50*
51* Z (local input/local output) COMPLEX array, global
52* dimension (N, N), local dimension (LDZ, NR).
53* On entry, if COMPZ = 'V', then Z contains the orthogonal
54* matrix used in the reduction to tridiagonal form.
55* On exit, if INFO = 0, then if COMPZ = 'V', Z contains the
56* orthonormal eigenvectors of the original symmetric matrix,
57* and if COMPZ = 'I', Z contains the orthonormal eigenvectors
58* of the symmetric tridiagonal matrix.
59* If COMPZ = 'N', then Z is not referenced.
60*
61* LDZ (input) INTEGER
62* The leading dimension of the array Z. LDZ >= 1, and if
63* eigenvectors are desired, then LDZ >= max(1,N).
64*
65* NR (input) INTEGER
66* NR = MAX(1, NUMROC( N, NB, MYPROW, 0, NPROCS ) ).
67* If COMPZ = 'N', then NR is not referenced.
68*
69* WORK (workspace) REAL array, dimension (max(1,2*N-2))
70* If COMPZ = 'N', then WORK is not referenced.
71*
72* INFO (output) INTEGER
73* = 0: successful exit
74* < 0: if INFO = -i, the i-th argument had an illegal value
75* > 0: the algorithm has failed to find all the eigenvalues in
76* a total of 30*N iterations; if INFO = i, then i
77* elements of E have not converged to zero; on exit, D
78* and E contain the elements of a symmetric tridiagonal
79* matrix which is orthogonally similar to the original
80* matrix.
81*
82* =====================================================================
83*
84* .. Parameters ..
85 REAL ZERO, ONE, TWO, THREE, HALF
86 parameter( zero = 0.0e0, one = 1.0e0, two = 2.0e0,
87 $ three = 3.0e0, half = 0.5e0 )
88 COMPLEX CONE
89 parameter( cone = ( 1.0e0, 1.0e0 ) )
90 INTEGER MAXIT, NMAXLOOK
91 parameter( maxit = 30, nmaxlook = 15 )
92* ..
93* .. Local Scalars ..
94 INTEGER I, ICOMPZ, II, ILAST, ISCALE, J, JTOT, K, L,
95 $ L1, LEND, LENDM1, LENDP1, LENDSV, LM1, LSV, M,
96 $ MM, MM1, NLOOK, NM1, NMAXIT
97 REAL ANORM, B, C, EPS, EPS2, F, G, GP, OLDEL, OLDGP,
98 $ OLDRP, P, R, RP, RT1, RT2, S, SAFMAX, SAFMIN,
99 $ SSFMAX, SSFMIN, TST, TST1
100* ..
101* .. External Functions ..
102 LOGICAL LSAME
103 REAL SLAMCH, SLANST, SLAPY2
104 EXTERNAL lsame, slamch, slanst, slapy2
105* ..
106* .. External Subroutines ..
107 EXTERNAL clasr, cswap, slaev2, slartg, slascl, ssterf,
108 $ xerbla
109* ..
110* .. Intrinsic Functions ..
111 INTRINSIC abs, max, sign, sqrt
112* ..
113* .. Executable Statements ..
114*
115* Test the input parameters.
116*
117 ilast = 0
118 info = 0
119*
120 IF( lsame( compz, 'N' ) ) THEN
121 icompz = 0
122 ELSEIF( lsame( compz, 'I' ) ) THEN
123 icompz = 1
124 ELSE
125 icompz = -1
126 ENDIF
127 IF( icompz.LT.0 ) THEN
128 info = -1
129 ELSEIF( n.LT.0 ) THEN
130 info = -2
131 ELSEIF( icompz.GT.0 .AND. ldz.LT.max( 1, nr ) ) THEN
132 info = -6
133 ENDIF
134 IF( info.NE.0 ) THEN
135 CALL xerbla( 'CSTEQR2', -info )
136 RETURN
137 ENDIF
138*
139* Quick return if possible
140*
141 IF( n.EQ.0 )
142 $ RETURN
143*
144* If eigenvectors aren't not desired, this is faster
145*
146 IF( icompz.EQ.0 ) THEN
147 CALL ssterf( n, d, e, info )
148 RETURN
149 ENDIF
150*
151 IF( n.EQ.1 ) THEN
152 z( 1, 1 ) = cone
153 RETURN
154 ENDIF
155*
156* Determine the unit roundoff and over/underflow thresholds.
157*
158 eps = slamch( 'E' )
159 eps2 = eps**2
160 safmin = slamch( 'S' )
161 safmax = one / safmin
162 ssfmax = sqrt( safmax ) / three
163 ssfmin = sqrt( safmin ) / eps2
164*
165* Compute the eigenvalues and eigenvectors of the tridiagonal
166* matrix.
167*
168 nmaxit = n*maxit
169 jtot = 0
170*
171* Determine where the matrix splits and choose QL or QR iteration
172* for each block, according to whether top or bottom diagonal
173* element is smaller.
174*
175 l1 = 1
176 nm1 = n - 1
177*
178 10 CONTINUE
179 IF( l1.GT.n )
180 $ GOTO 220
181 IF( l1.GT.1 )
182 $ e( l1-1 ) = zero
183 IF( l1.LE.nm1 ) THEN
184 DO 20 m = l1, nm1
185 tst = abs( e( m ) )
186 IF( tst.EQ.zero )
187 $ GOTO 30
188 IF( tst.LE.( sqrt( abs( d( m ) ) )*sqrt( abs( d( m+
189 $ 1 ) ) ) )*eps ) THEN
190 e( m ) = zero
191 GOTO 30
192 ENDIF
193 20 CONTINUE
194 ENDIF
195 m = n
196*
197 30 CONTINUE
198 l = l1
199 lsv = l
200 lend = m
201 lendsv = lend
202 l1 = m + 1
203 IF( lend.EQ.l )
204 $ GOTO 10
205*
206* Scale submatrix in rows and columns L to LEND
207*
208 anorm = slanst( 'I', lend-l+1, d( l ), e( l ) )
209 iscale = 0
210 IF( anorm.EQ.zero )
211 $ GOTO 10
212 IF( anorm.GT.ssfmax ) THEN
213 iscale = 1
214 CALL slascl( 'G', 0, 0, anorm, ssfmax, lend-l+1, 1, d( l ), n,
215 $ info )
216 CALL slascl( 'G', 0, 0, anorm, ssfmax, lend-l, 1, e( l ), n,
217 $ info )
218 ELSEIF( anorm.LT.ssfmin ) THEN
219 iscale = 2
220 CALL slascl( 'G', 0, 0, anorm, ssfmin, lend-l+1, 1, d( l ), n,
221 $ info )
222 CALL slascl( 'G', 0, 0, anorm, ssfmin, lend-l, 1, e( l ), n,
223 $ info )
224 ENDIF
225*
226* Choose between QL and QR iteration
227*
228 IF( abs( d( lend ) ).LT.abs( d( l ) ) ) THEN
229 lend = lsv
230 l = lendsv
231 ENDIF
232*
233 IF( lend.GT.l ) THEN
234*
235* QL Iteration
236*
237* Look for small subdiagonal element.
238*
239 40 CONTINUE
240 IF( l.NE.lend ) THEN
241 lendm1 = lend - 1
242 DO 50 m = l, lendm1
243 tst = abs( e( m ) )**2
244 IF( tst.LE.( eps2*abs( d( m ) ) )*abs( d( m+1 ) )+
245 $ safmin )GOTO 60
246 50 CONTINUE
247 ENDIF
248*
249 m = lend
250*
251 60 CONTINUE
252 IF( m.LT.lend )
253 $ e( m ) = zero
254 p = d( l )
255 IF( m.EQ.l )
256 $ GOTO 110
257*
258* If remaining matrix is 2-by-2, use SLAE2 or SLAEV2
259* to compute its eigensystem.
260*
261 IF( m.EQ.l+1 ) THEN
262 CALL slaev2( d( l ), e( l ), d( l+1 ), rt1, rt2, c, s )
263 work( l ) = c
264 work( n-1+l ) = s
265 CALL clasr( 'r', 'v', 'b', NR, 2, WORK( L ), WORK( N-1+L ),
266 $ Z( 1, L ), LDZ )
267 D( L ) = RT1
268 D( L+1 ) = RT2
269 E( L ) = ZERO
270 L = L + 2
271.LE. IF( LLEND )
272 $ GOTO 40
273 GOTO 200
274 ENDIF
275*
276.EQ. IF( JTOTNMAXIT )
277 $ GOTO 200
278 JTOT = JTOT + 1
279*
280* Form shift.
281*
282 G = ( D( L+1 )-P ) / ( TWO*E( L ) )
283 R = SLAPY2( G, ONE )
284 G = D( M ) - P + ( E( L ) / ( G+SIGN( R, G ) ) )
285*
286.EQ. IF( ICOMPZ0 ) THEN
287* Do not do a lookahead!
288 GOTO 90
289 ENDIF
290*
291 OLDEL = ABS( E( L ) )
292 GP = G
293 RP = R
294 TST = ABS( E( L ) )**2
295 TST = TST / ( ( EPS2*ABS( D( L ) ) )*ABS( D( L+1 ) )+SAFMIN )
296*
297 NLOOK = 1
298.GT..AND..LE. IF( ( TSTONE ) ( NLOOKNMAXLOOK ) ) THEN
299 70 CONTINUE
300*
301* This is the lookahead loop, going until we have
302* convergence or too many steps have been taken.
303*
304 S = ONE
305 C = ONE
306 P = ZERO
307 MM1 = M - 1
308 DO 80 I = MM1, L, -1
309 F = S*E( I )
310 B = C*E( I )
311 CALL SLARTG( GP, F, C, S, RP )
312 GP = D( I+1 ) - P
313 RP = ( D( I )-GP )*S + TWO*C*B
314 P = S*RP
315.NE. IF( IL )
316 $ GP = C*RP - B
317 80 CONTINUE
318 OLDGP = GP
319 OLDRP = RP
320* Find GP & RP for the next iteration
321.GT. IF( ABS( C*OLDRP-B )SAFMIN ) THEN
322 GP = ( ( OLDGP+P )-( D( L )-P ) ) / ( TWO*( C*OLDRP-B ) )
323 ELSE
324*
325* Goto put in by G. Henry to fix ALPHA problem
326*
327 GOTO 90
328* GP = ( ( OLDGP+P )-( D( L )-P ) ) /
329* $ ( TWO*( C*OLDRP-B )+SAFMIN )
330 ENDIF
331 RP = SLAPY2( GP, ONE )
332 GP = D( M ) - ( D( L )-P ) +
333 $ ( ( C*OLDRP-B ) / ( GP+SIGN( RP, GP ) ) )
334 TST1 = TST
335 TST = ABS( C*OLDRP-B )**2
336 TST = TST / ( ( EPS2*ABS( D( L )-P ) )*ABS( OLDGP+P )+
337 $ SAFMIN )
338* Make sure that we are making progress
339.GT. IF( ABS( C*OLDRP-B )0.9E0*OLDEL ) THEN
340.GT. IF( ABS( C*OLDRP-B )OLDEL ) THEN
341 GP = G
342 RP = R
343 ENDIF
344 TST = HALF
345 ELSE
346 OLDEL = ABS( C*OLDRP-B )
347 ENDIF
348 NLOOK = NLOOK + 1
349.GT..AND..LE. IF( ( TSTONE ) ( NLOOKNMAXLOOK ) )
350 $ GOTO 70
351 ENDIF
352*
353.LE..AND..NE..AND. IF( ( TSTONE ) ( TSTHALF )
354.LT..AND. $ ( ABS( P )EPS*ABS( D( L ) ) )
355.EQ..AND..LE. $ ( ILASTL ) ( ABS( E( L ) )**210000.0E0*
356 $ ( ( EPS2*ABS( D( L ) ) )*ABS( D( L+1 ) )+SAFMIN ) ) ) THEN
357*
358* Skip the current step: the subdiagonal info is just noise.
359*
360 M = L
361 E( M ) = ZERO
362 P = D( L )
363 JTOT = JTOT - 1
364 GOTO 110
365 ENDIF
366 G = GP
367 R = RP
368*
369* Lookahead over
370*
371 90 CONTINUE
372*
373 S = ONE
374 C = ONE
375 P = ZERO
376*
377* Inner loop
378*
379 MM1 = M - 1
380 DO 100 I = MM1, L, -1
381 F = S*E( I )
382 B = C*E( I )
383 CALL SLARTG( G, F, C, S, R )
384.NE. IF( IM-1 )
385 $ E( I+1 ) = R
386 G = D( I+1 ) - P
387 R = ( D( I )-G )*S + TWO*C*B
388 P = S*R
389 D( I+1 ) = G + P
390 G = C*R - B
391*
392* If eigenvectors are desired, then save rotations.
393*
394 WORK( I ) = C
395 WORK( N-1+I ) = -S
396*
397 100 CONTINUE
398*
399* If eigenvectors are desired, then apply saved rotations.
400*
401 MM = M - L + 1
402 CALL CLASR( 'r', 'v', 'b', NR, MM, WORK( L ), WORK( N-1+L ),
403 $ Z( 1, L ), LDZ )
404*
405 D( L ) = D( L ) - P
406 E( L ) = G
407 ILAST = L
408 GOTO 40
409*
410* Eigenvalue found.
411*
412 110 CONTINUE
413 D( L ) = P
414*
415 L = L + 1
416.LE. IF( LLEND )
417 $ GOTO 40
418 GOTO 200
419*
420 ELSE
421*
422* QR Iteration
423*
424* Look for small superdiagonal element.
425*
426 120 CONTINUE
427.NE. IF( LLEND ) THEN
428 LENDP1 = LEND + 1
429 DO 130 M = L, LENDP1, -1
430 TST = ABS( E( M-1 ) )**2
431.LE. IF( TST( EPS2*ABS( D( M ) ) )*ABS( D( M-1 ) )+
432 $ SAFMIN )GOTO 140
433 130 CONTINUE
434 ENDIF
435*
436 M = LEND
437*
438 140 CONTINUE
439.GT. IF( MLEND )
440 $ E( M-1 ) = ZERO
441 P = D( L )
442.EQ. IF( ML )
443 $ GOTO 190
444*
445* If remaining matrix is 2-by-2, use SLAE2 or SLAEV2
446* to compute its eigensystem.
447*
448.EQ. IF( ML-1 ) THEN
449 CALL SLAEV2( D( L-1 ), E( L-1 ), D( L ), RT1, RT2, C, S )
450 WORK( M ) = C
451 WORK( N-1+M ) = S
452 CALL CLASR( 'r', 'v', 'f', NR, 2, WORK( M ), WORK( N-1+M ),
453 $ Z( 1, L-1 ), LDZ )
454 D( L-1 ) = RT1
455 D( L ) = RT2
456 E( L-1 ) = ZERO
457 L = L - 2
458.GE. IF( LLEND )
459 $ GOTO 120
460 GOTO 200
461 ENDIF
462*
463.EQ. IF( JTOTNMAXIT )
464 $ GOTO 200
465 JTOT = JTOT + 1
466*
467* Form shift.
468*
469 G = ( D( L-1 )-P ) / ( TWO*E( L-1 ) )
470 R = SLAPY2( G, ONE )
471 G = D( M ) - P + ( E( L-1 ) / ( G+SIGN( R, G ) ) )
472*
473.EQ. IF( ICOMPZ0 ) THEN
474* Do not do a lookahead!
475 GOTO 170
476 ENDIF
477*
478 OLDEL = ABS( E( L-1 ) )
479 GP = G
480 RP = R
481 TST = ABS( E( L-1 ) )**2
482 TST = TST / ( ( EPS2*ABS( D( L ) ) )*ABS( D( L-1 ) )+SAFMIN )
483 NLOOK = 1
484.GT..AND..LE. IF( ( TSTONE ) ( NLOOKNMAXLOOK ) ) THEN
485 150 CONTINUE
486*
487* This is the lookahead loop, going until we have
488* convergence or too many steps have been taken.
489*
490 S = ONE
491 C = ONE
492 P = ZERO
493*
494* Inner loop
495*
496 LM1 = L - 1
497 DO 160 I = M, LM1
498 F = S*E( I )
499 B = C*E( I )
500 CALL SLARTG( GP, F, C, S, RP )
501 GP = D( I ) - P
502 RP = ( D( I+1 )-GP )*S + TWO*C*B
503 P = S*RP
504.LT. IF( ILM1 )
505 $ GP = C*RP - B
506 160 CONTINUE
507 OLDGP = GP
508 OLDRP = RP
509* Find GP & RP for the next iteration
510.GT. IF( ABS( C*OLDRP-B )SAFMIN ) THEN
511 GP = ( ( OLDGP+P )-( D( L )-P ) ) / ( TWO*( C*OLDRP-B ) )
512 ELSE
513*
514* Goto put in by G. Henry to fix ALPHA problem
515*
516 GOTO 170
517* GP = ( ( OLDGP+P )-( D( L )-P ) ) /
518* $ ( TWO*( C*OLDRP-B )+SAFMIN )
519 ENDIF
520 RP = SLAPY2( GP, ONE )
521 GP = D( M ) - ( D( L )-P ) +
522 $ ( ( C*OLDRP-B ) / ( GP+SIGN( RP, GP ) ) )
523 TST1 = TST
524 TST = ABS( ( C*OLDRP-B ) )**2
525 TST = TST / ( ( EPS2*ABS( D( L )-P ) )*ABS( OLDGP+P )+
526 $ SAFMIN )
527* Make sure that we are making progress
528.GT. IF( ABS( C*OLDRP-B )0.9E0*OLDEL ) THEN
529.GT. IF( ABS( C*OLDRP-B )OLDEL ) THEN
530 GP = G
531 RP = R
532 ENDIF
533 TST = HALF
534 ELSE
535 OLDEL = ABS( C*OLDRP-B )
536 ENDIF
537 NLOOK = NLOOK + 1
538.GT..AND..LE. IF( ( TSTONE ) ( NLOOKNMAXLOOK ) )
539 $ GOTO 150
540 ENDIF
541.LE..AND..NE..AND. IF( ( TSTONE ) ( TSTHALF )
542.LT..AND. $ ( ABS( P )EPS*ABS( D( L ) ) )
543.EQ..AND..LE. $ ( ILASTL ) ( ABS( E( L-1 ) )**210000.0E0*
544 $ ( ( EPS2*ABS( D( L-1 ) ) )*ABS( D( L ) )+SAFMIN ) ) ) THEN
545*
546* Skip the current step: the subdiagonal info is just noise.
547*
548 M = L
549 E( M-1 ) = ZERO
550 P = D( L )
551 JTOT = JTOT - 1
552 GOTO 190
553 ENDIF
554*
555 G = GP
556 R = RP
557*
558* Lookahead over
559*
560 170 CONTINUE
561*
562 S = ONE
563 C = ONE
564 P = ZERO
565 DO 180 I = M, LM1
566 F = S*E( I )
567 B = C*E( I )
568 CALL SLARTG( G, F, C, S, R )
569.NE. IF( IM )
570 $ E( I-1 ) = R
571 G = D( I ) - P
572 R = ( D( I+1 )-G )*S + TWO*C*B
573 P = S*R
574 D( I ) = G + P
575 G = C*R - B
576*
577* If eigenvectors are desired, then save rotations.
578*
579 WORK( I ) = C
580 WORK( N-1+I ) = S
581*
582 180 CONTINUE
583*
584* If eigenvectors are desired, then apply saved rotations.
585*
586 MM = L - M + 1
587 CALL CLASR( 'r', 'v', 'f', NR, MM, WORK( M ), WORK( N-1+M ),
588 $ Z( 1, M ), LDZ )
589*
590 D( L ) = D( L ) - P
591 E( LM1 ) = G
592 ILAST = L
593 GOTO 120
594*
595* Eigenvalue found.
596*
597 190 CONTINUE
598 D( L ) = P
599*
600 L = L - 1
601.GE. IF( LLEND )
602 $ GOTO 120
603 GOTO 200
604*
605 ENDIF
606*
607* Undo scaling if necessary
608*
609 200 CONTINUE
610.EQ. IF( ISCALE1 ) THEN
611 CALL SLASCL( 'g', 0, 0, SSFMAX, ANORM, LENDSV-LSV+1, 1,
612 $ D( LSV ), N, INFO )
613 CALL SLASCL( 'g', 0, 0, SSFMAX, ANORM, LENDSV-LSV, 1, E( LSV ),
614 $ N, INFO )
615.EQ. ELSEIF( ISCALE2 ) THEN
616 CALL SLASCL( 'g', 0, 0, SSFMIN, ANORM, LENDSV-LSV+1, 1,
617 $ D( LSV ), N, INFO )
618 CALL SLASCL( 'g', 0, 0, SSFMIN, ANORM, LENDSV-LSV, 1, E( LSV ),
619 $ N, INFO )
620 ENDIF
621*
622* Check for no convergence to an eigenvalue after a total
623* of N*MAXIT iterations.
624*
625.LT. IF( JTOTNMAXIT )
626 $ GOTO 10
627 DO 210 I = 1, N - 1
628.NE. IF( E( I )ZERO )
629 $ INFO = INFO + 1
630 210 CONTINUE
631 GOTO 250
632*
633* Order eigenvalues and eigenvectors.
634*
635 220 CONTINUE
636*
637* Use Selection Sort to minimize swaps of eigenvectors
638*
639 DO 240 II = 2, N
640 I = II - 1
641 K = I
642 P = D( I )
643 DO 230 J = II, N
644.LT. IF( D( J )P ) THEN
645 K = J
646 P = D( J )
647 ENDIF
648 230 CONTINUE
649.NE. IF( KI ) THEN
650 D( K ) = D( I )
651 D( I ) = P
652 CALL CSWAP( NR, Z( 1, I ), 1, Z( 1, K ), 1 )
653 ENDIF
654 240 CONTINUE
655*
656 250 CONTINUE
657* WRITE( *, FMT = * )'JTOT', JTOT
658 RETURN
659*
660* End of SSTEQR2
661*
slapy2
real function slapy2(x, y)
SLAPY2 returns sqrt(x2+y2).
Definition slapy2.f:63
slartg
subroutine slartg(f, g, c, s, r)
SLARTG generates a plane rotation with real cosine and real sine.
Definition slartg.f90:113
slaev2
subroutine slaev2(a, b, c, rt1, rt2, cs1, sn1)
SLAEV2 computes the eigenvalues and eigenvectors of a 2-by-2 symmetric/Hermitian matrix.
Definition slaev2.f:120
slascl
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
slanst
real function slanst(norm, n, d, e)
SLANST returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition slanst.f:100
ssterf
subroutine ssterf(n, d, e, info)
SSTERF
Definition ssterf.f:86
xerbla
subroutine xerbla(srname, info)
XERBLA
Definition xerbla.f:60
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:53
clasr
subroutine clasr(side, pivot, direct, m, n, c, s, a, lda)
CLASR applies a sequence of plane rotations to a general rectangular matrix.
Definition clasr.f:200
cswap
subroutine cswap(n, cx, incx, cy, incy)
CSWAP
Definition cswap.f:81
slamch
real function slamch(cmach)
SLAMCH
Definition slamch.f:68
max
#define max(a, b)
Definition macros.h:21