OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
cdrvhe.f
Go to the documentation of this file.
1*> \brief \b CDRVHE
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8* Definition:
9* ===========
10*
11* SUBROUTINE CDRVHE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
12* A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
13* NOUT )
14*
15* .. Scalar Arguments ..
16* LOGICAL TSTERR
17* INTEGER NMAX, NN, NOUT, NRHS
18* REAL THRESH
19* ..
20* .. Array Arguments ..
21* LOGICAL DOTYPE( * )
22* INTEGER IWORK( * ), NVAL( * )
23* REAL RWORK( * )
24* COMPLEX A( * ), AFAC( * ), AINV( * ), B( * ),
25* $ WORK( * ), X( * ), XACT( * )
26* ..
27*
28*
29*> \par Purpose:
30* =============
31*>
32*> \verbatim
33*>
34*> CDRVHE tests the driver routines CHESV and -SVX.
35*> \endverbatim
36*
37* Arguments:
38* ==========
39*
40*> \param[in] DOTYPE
41*> \verbatim
42*> DOTYPE is LOGICAL array, dimension (NTYPES)
43*> The matrix types to be used for testing. Matrices of type j
44*> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
45*> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
46*> \endverbatim
47*>
48*> \param[in] NN
49*> \verbatim
50*> NN is INTEGER
51*> The number of values of N contained in the vector NVAL.
52*> \endverbatim
53*>
54*> \param[in] NVAL
55*> \verbatim
56*> NVAL is INTEGER array, dimension (NN)
57*> The values of the matrix dimension N.
58*> \endverbatim
59*>
60*> \param[in] NRHS
61*> \verbatim
62*> NRHS is INTEGER
63*> The number of right hand side vectors to be generated for
64*> each linear system.
65*> \endverbatim
66*>
67*> \param[in] THRESH
68*> \verbatim
69*> THRESH is REAL
70*> The threshold value for the test ratios. A result is
71*> included in the output file if RESULT >= THRESH. To have
72*> every test ratio printed, use THRESH = 0.
73*> \endverbatim
74*>
75*> \param[in] TSTERR
76*> \verbatim
77*> TSTERR is LOGICAL
78*> Flag that indicates whether error exits are to be tested.
79*> \endverbatim
80*>
81*> \param[in] NMAX
82*> \verbatim
83*> NMAX is INTEGER
84*> The maximum value permitted for N, used in dimensioning the
85*> work arrays.
86*> \endverbatim
87*>
88*> \param[out] A
89*> \verbatim
90*> A is COMPLEX array, dimension (NMAX*NMAX)
91*> \endverbatim
92*>
93*> \param[out] AFAC
94*> \verbatim
95*> AFAC is COMPLEX array, dimension (NMAX*NMAX)
96*> \endverbatim
97*>
98*> \param[out] AINV
99*> \verbatim
100*> AINV is COMPLEX array, dimension (NMAX*NMAX)
101*> \endverbatim
102*>
103*> \param[out] B
104*> \verbatim
105*> B is COMPLEX array, dimension (NMAX*NRHS)
106*> \endverbatim
107*>
108*> \param[out] X
109*> \verbatim
110*> X is COMPLEX array, dimension (NMAX*NRHS)
111*> \endverbatim
112*>
113*> \param[out] XACT
114*> \verbatim
115*> XACT is COMPLEX array, dimension (NMAX*NRHS)
116*> \endverbatim
117*>
118*> \param[out] WORK
119*> \verbatim
120*> WORK is COMPLEX array, dimension (NMAX*max(2,NRHS))
121*> \endverbatim
122*>
123*> \param[out] RWORK
124*> \verbatim
125*> RWORK is REAL array, dimension (NMAX+2*NRHS)
126*> \endverbatim
127*>
128*> \param[out] IWORK
129*> \verbatim
130*> IWORK is INTEGER array, dimension (NMAX)
131*> \endverbatim
132*>
133*> \param[in] NOUT
134*> \verbatim
135*> NOUT is INTEGER
136*> The unit number for output.
137*> \endverbatim
138*
139* Authors:
140* ========
141*
142*> \author Univ. of Tennessee
143*> \author Univ. of California Berkeley
144*> \author Univ. of Colorado Denver
145*> \author NAG Ltd.
146*
147*> \ingroup complex_lin
148*
149* =====================================================================
150 SUBROUTINE cdrvhe( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
151 $ A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
152 $ NOUT )
153*
154* -- LAPACK test routine --
155* -- LAPACK is a software package provided by Univ. of Tennessee, --
156* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
157*
158* .. Scalar Arguments ..
159 LOGICAL TSTERR
160 INTEGER NMAX, NN, NOUT, NRHS
161 REAL THRESH
162* ..
163* .. Array Arguments ..
164 LOGICAL DOTYPE( * )
165 INTEGER IWORK( * ), NVAL( * )
166 REAL RWORK( * )
167 COMPLEX A( * ), AFAC( * ), AINV( * ), B( * ),
168 $ work( * ), x( * ), xact( * )
169* ..
170*
171* =====================================================================
172*
173* .. Parameters ..
174 REAL ONE, ZERO
175 PARAMETER ( ONE = 1.0e+0, zero = 0.0e+0 )
176 INTEGER NTYPES, NTESTS
177 parameter( ntypes = 10, ntests = 6 )
178 INTEGER NFACT
179 parameter( nfact = 2 )
180* ..
181* .. Local Scalars ..
182 LOGICAL ZEROT
183 CHARACTER DIST, FACT, TYPE, UPLO, XTYPE
184 CHARACTER*3 PATH
185 INTEGER I, I1, I2, IFACT, IMAT, IN, INFO, IOFF, IUPLO,
186 $ izero, j, k, k1, kl, ku, lda, lwork, mode, n,
187 $ nb, nbmin, nerrs, nfail, nimat, nrun, nt
188 REAL AINVNM, ANORM, CNDNUM, RCOND, RCONDC
189* ..
190* .. Local Arrays ..
191 CHARACTER FACTS( NFACT ), UPLOS( 2 )
192 INTEGER ISEED( 4 ), ISEEDY( 4 )
193 REAL RESULT( NTESTS )
194* ..
195* .. External Functions ..
196 REAL CLANHE, SGET06
197 EXTERNAL CLANHE, SGET06
198* ..
199* .. External Subroutines ..
200 EXTERNAL aladhd, alaerh, alasvm, cerrvx, cget04, chesv,
201 $ chesvx, chet01, chetrf, chetri2, clacpy,
202 $ claipd, clarhs, claset, clatb4, clatms, cpot02,
203 $ cpot05, xlaenv
204* ..
205* .. Scalars in Common ..
206 LOGICAL LERR, OK
207 CHARACTER*32 SRNAMT
208 INTEGER INFOT, NUNIT
209* ..
210* .. Common blocks ..
211 COMMON / infoc / infot, nunit, ok, lerr
212 COMMON / srnamc / srnamt
213* ..
214* .. Intrinsic Functions ..
215 INTRINSIC cmplx, max, min
216* ..
217* .. Data statements ..
218 DATA iseedy / 1988, 1989, 1990, 1991 /
219 DATA uplos / 'U', 'L' / , facts / 'f', 'n' /
220* ..
221* .. Executable Statements ..
222*
223* Initialize constants and the random number seed.
224*
225 PATH( 1: 1 ) = 'Complex precision'
226 PATH( 2: 3 ) = 'HE'
227 NRUN = 0
228 NFAIL = 0
229 NERRS = 0
230 DO 10 I = 1, 4
231 ISEED( I ) = ISEEDY( I )
232 10 CONTINUE
233 LWORK = MAX( 2*NMAX, NMAX*NRHS )
234*
235* Test the error exits
236*
237 IF( TSTERR )
238 $ CALL CERRVX( PATH, NOUT )
239 INFOT = 0
240*
241* Set the block size and minimum block size for testing.
242*
243 NB = 1
244 NBMIN = 2
245 CALL XLAENV( 1, NB )
246 CALL XLAENV( 2, NBMIN )
247*
248* Do for each value of N in NVAL
249*
250 DO 180 IN = 1, NN
251 N = NVAL( IN )
252 LDA = MAX( N, 1 )
253 XTYPE = 'N'
254 NIMAT = NTYPES
255.LE. IF( N0 )
256 $ NIMAT = 1
257*
258 DO 170 IMAT = 1, NIMAT
259*
260* Do the tests only if DOTYPE( IMAT ) is true.
261*
262.NOT. IF( DOTYPE( IMAT ) )
263 $ GO TO 170
264*
265* Skip types 3, 4, 5, or 6 if the matrix size is too small.
266*
267.GE..AND..LE. ZEROT = IMAT3 IMAT6
268.AND..LT. IF( ZEROT NIMAT-2 )
269 $ GO TO 170
270*
271* Do first for UPLO = 'U', then for UPLO = 'L'
272*
273 DO 160 IUPLO = 1, 2
274 UPLO = UPLOS( IUPLO )
275*
276* Set up parameters with CLATB4 and generate a test matrix
277* with CLATMS.
278*
279 CALL CLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
280 $ CNDNUM, DIST )
281*
282 SRNAMT = 'CLATMS'
283 CALL CLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
284 $ CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
285 $ INFO )
286*
287* Check error code from CLATMS.
288*
289.NE. IF( INFO0 ) THEN
290 CALL ALAERH( PATH, 'CLATMS', INFO, 0, UPLO, N, N, -1,
291 $ -1, -1, IMAT, NFAIL, NERRS, NOUT )
292 GO TO 160
293 END IF
294*
295* For types 3-6, zero one or more rows and columns of the
296* matrix to test that INFO is returned correctly.
297*
298 IF( ZEROT ) THEN
299.EQ. IF( IMAT3 ) THEN
300 IZERO = 1
301.EQ. ELSE IF( IMAT4 ) THEN
302 IZERO = N
303 ELSE
304 IZERO = N / 2 + 1
305 END IF
306*
307.LT. IF( IMAT6 ) THEN
308*
309* Set row and column IZERO to zero.
310*
311.EQ. IF( IUPLO1 ) THEN
312 IOFF = ( IZERO-1 )*LDA
313 DO 20 I = 1, IZERO - 1
314 A( IOFF+I ) = ZERO
315 20 CONTINUE
316 IOFF = IOFF + IZERO
317 DO 30 I = IZERO, N
318 A( IOFF ) = ZERO
319 IOFF = IOFF + LDA
320 30 CONTINUE
321 ELSE
322 IOFF = IZERO
323 DO 40 I = 1, IZERO - 1
324 A( IOFF ) = ZERO
325 IOFF = IOFF + LDA
326 40 CONTINUE
327 IOFF = IOFF - IZERO
328 DO 50 I = IZERO, N
329 A( IOFF+I ) = ZERO
330 50 CONTINUE
331 END IF
332 ELSE
333 IOFF = 0
334.EQ. IF( IUPLO1 ) THEN
335*
336* Set the first IZERO rows and columns to zero.
337*
338 DO 70 J = 1, N
339 I2 = MIN( J, IZERO )
340 DO 60 I = 1, I2
341 A( IOFF+I ) = ZERO
342 60 CONTINUE
343 IOFF = IOFF + LDA
344 70 CONTINUE
345 ELSE
346*
347* Set the last IZERO rows and columns to zero.
348*
349 DO 90 J = 1, N
350 I1 = MAX( J, IZERO )
351 DO 80 I = I1, N
352 A( IOFF+I ) = ZERO
353 80 CONTINUE
354 IOFF = IOFF + LDA
355 90 CONTINUE
356 END IF
357 END IF
358 ELSE
359 IZERO = 0
360 END IF
361*
362* Set the imaginary part of the diagonals.
363*
364 CALL CLAIPD( N, A, LDA+1, 0 )
365*
366 DO 150 IFACT = 1, NFACT
367*
368* Do first for FACT = 'F', then for other values.
369*
370 FACT = FACTS( IFACT )
371*
372* Compute the condition number for comparison with
373* the value returned by CHESVX.
374*
375 IF( ZEROT ) THEN
376.EQ. IF( IFACT1 )
377 $ GO TO 150
378 RCONDC = ZERO
379*
380.EQ. ELSE IF( IFACT1 ) THEN
381*
382* Compute the 1-norm of A.
383*
384 ANORM = CLANHE( '1', UPLO, N, A, LDA, RWORK )
385*
386* Factor the matrix A.
387*
388 CALL CLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
389 CALL CHETRF( UPLO, N, AFAC, LDA, IWORK, WORK,
390 $ LWORK, INFO )
391*
392* Compute inv(A) and take its norm.
393*
394 CALL CLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
395 LWORK = (N+NB+1)*(NB+3)
396 CALL CHETRI2( UPLO, N, AINV, LDA, IWORK, WORK,
397 $ LWORK, INFO )
398 AINVNM = CLANHE( '1', UPLO, N, AINV, LDA, RWORK )
399*
400* Compute the 1-norm condition number of A.
401*
402.LE..OR..LE. IF( ANORMZERO AINVNMZERO ) THEN
403 RCONDC = ONE
404 ELSE
405 RCONDC = ( ONE / ANORM ) / AINVNM
406 END IF
407 END IF
408*
409* Form an exact solution and set the right hand side.
410*
411 SRNAMT = 'CLARHS'
412 CALL CLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
413 $ NRHS, A, LDA, XACT, LDA, B, LDA, ISEED,
414 $ INFO )
415 XTYPE = 'C'
416*
417* --- Test CHESV ---
418*
419.EQ. IF( IFACT2 ) THEN
420 CALL CLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
421 CALL CLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
422*
423* Factor the matrix and solve the system using CHESV.
424*
425 SRNAMT = 'CHESV '
426 CALL CHESV( UPLO, N, NRHS, AFAC, LDA, IWORK, X,
427 $ LDA, WORK, LWORK, INFO )
428*
429* Adjust the expected value of INFO to account for
430* pivoting.
431*
432 K = IZERO
433.GT. IF( K0 ) THEN
434 100 CONTINUE
435.LT. IF( IWORK( K )0 ) THEN
436.NE. IF( IWORK( K )-K ) THEN
437 K = -IWORK( K )
438 GO TO 100
439 END IF
440.NE. ELSE IF( IWORK( K )K ) THEN
441 K = IWORK( K )
442 GO TO 100
443 END IF
444 END IF
445*
446* Check error code from CHESV .
447*
448.NE. IF( INFOK ) THEN
449 CALL ALAERH( PATH, 'CHESV ', INFO, K, UPLO, N,
450 $ N, -1, -1, NRHS, IMAT, NFAIL,
451 $ NERRS, NOUT )
452 GO TO 120
453.NE. ELSE IF( INFO0 ) THEN
454 GO TO 120
455 END IF
456*
457* Reconstruct matrix from factors and compute
458* residual.
459*
460 CALL CHET01( UPLO, N, A, LDA, AFAC, LDA, IWORK,
461 $ AINV, LDA, RWORK, RESULT( 1 ) )
462*
463* Compute residual of the computed solution.
464*
465 CALL CLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
466 CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
467 $ LDA, RWORK, RESULT( 2 ) )
468*
469* Check solution from generated exact solution.
470*
471 CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
472 $ RESULT( 3 ) )
473 NT = 3
474*
475* Print information about the tests that did not pass
476* the threshold.
477*
478 DO 110 K = 1, NT
479.GE. IF( RESULT( K )THRESH ) THEN
480.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
481 $ CALL ALADHD( NOUT, PATH )
482 WRITE( NOUT, FMT = 9999 )'CHESV ', UPLO, N,
483 $ IMAT, K, RESULT( K )
484 NFAIL = NFAIL + 1
485 END IF
486 110 CONTINUE
487 NRUN = NRUN + NT
488 120 CONTINUE
489 END IF
490*
491* --- Test CHESVX ---
492*
493.EQ. IF( IFACT2 )
494 $ CALL CLASET( UPLO, N, N, CMPLX( ZERO ),
495 $ CMPLX( ZERO ), AFAC, LDA )
496 CALL CLASET( 'Full', N, NRHS, CMPLX( ZERO ),
497 $ CMPLX( ZERO ), X, LDA )
498*
499* Solve the system and compute the condition number and
500* error bounds using CHESVX.
501*
502 SRNAMT = 'CHESVX'
503 CALL CHESVX( FACT, UPLO, N, NRHS, A, LDA, AFAC, LDA,
504 $ IWORK, B, LDA, X, LDA, RCOND, RWORK,
505 $ RWORK( NRHS+1 ), WORK, LWORK,
506 $ RWORK( 2*NRHS+1 ), INFO )
507*
508* Adjust the expected value of INFO to account for
509* pivoting.
510*
511 K = IZERO
512.GT. IF( K0 ) THEN
513 130 CONTINUE
514.LT. IF( IWORK( K )0 ) THEN
515.NE. IF( IWORK( K )-K ) THEN
516 K = -IWORK( K )
517 GO TO 130
518 END IF
519.NE. ELSE IF( IWORK( K )K ) THEN
520 K = IWORK( K )
521 GO TO 130
522 END IF
523 END IF
524*
525* Check the error code from CHESVX.
526*
527.NE. IF( INFOK ) THEN
528 CALL ALAERH( PATH, 'CHESVX', INFO, K, FACT // UPLO,
529 $ N, N, -1, -1, NRHS, IMAT, NFAIL,
530 $ NERRS, NOUT )
531 GO TO 150
532 END IF
533*
534.EQ. IF( INFO0 ) THEN
535.GE. IF( IFACT2 ) THEN
536*
537* Reconstruct matrix from factors and compute
538* residual.
539*
540 CALL CHET01( UPLO, N, A, LDA, AFAC, LDA, IWORK,
541 $ AINV, LDA, RWORK( 2*NRHS+1 ),
542 $ RESULT( 1 ) )
543 K1 = 1
544 ELSE
545 K1 = 2
546 END IF
547*
548* Compute residual of the computed solution.
549*
550 CALL CLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
551 CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
552 $ LDA, RWORK( 2*NRHS+1 ), RESULT( 2 ) )
553*
554* Check solution from generated exact solution.
555*
556 CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
557 $ RESULT( 3 ) )
558*
559* Check the error bounds from iterative refinement.
560*
561 CALL CPOT05( UPLO, N, NRHS, A, LDA, B, LDA, X, LDA,
562 $ XACT, LDA, RWORK, RWORK( NRHS+1 ),
563 $ RESULT( 4 ) )
564 ELSE
565 K1 = 6
566 END IF
567*
568* Compare RCOND from CHESVX with the computed value
569* in RCONDC.
570*
571 RESULT( 6 ) = SGET06( RCOND, RCONDC )
572*
573* Print information about the tests that did not pass
574* the threshold.
575*
576 DO 140 K = K1, 6
577.GE. IF( RESULT( K )THRESH ) THEN
578.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
579 $ CALL ALADHD( NOUT, PATH )
580 WRITE( NOUT, FMT = 9998 )'CHESVX', FACT, UPLO,
581 $ N, IMAT, K, RESULT( K )
582 NFAIL = NFAIL + 1
583 END IF
584 140 CONTINUE
585 NRUN = NRUN + 7 - K1
586*
587 150 CONTINUE
588*
589 160 CONTINUE
590 170 CONTINUE
591 180 CONTINUE
592*
593* Print a summary of the results.
594*
595 CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
596*
597 9999 FORMAT( 1X, A, ', UPLO=''', A1, ''', n =', I5, ', type ', I2,
598 $ ', test ', I2, ', ratio =', G12.5 )
599 9998 FORMAT( 1X, A, ', fact=''', A1, ''', uplo=''', A1, ''', n =', I5,
600 $ ', type ', I2, ', test ', I2, ', ratio =', G12.5 )
601 RETURN
602*
603* End of CDRVHE
604*
605 END
cmplx
float cmplx[2]
Definition pblas.h:136
xlaenv
subroutine xlaenv(ispec, nvalue)
XLAENV
Definition xlaenv.f:81
alasvm
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
aladhd
subroutine aladhd(iounit, path)
ALADHD
Definition aladhd.f:90
alaerh
subroutine alaerh(path, subnam, info, infoe, opts, m, n, kl, ku, n5, imat, nfail, nerrs, nout)
ALAERH
Definition alaerh.f:147
chetri2
subroutine chetri2(uplo, n, a, lda, ipiv, work, lwork, info)
CHETRI2
Definition chetri2.f:127
chetrf
subroutine chetrf(uplo, n, a, lda, ipiv, work, lwork, info)
CHETRF
Definition chetrf.f:177
chesvx
subroutine chesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info)
CHESVX computes the solution to system of linear equations A * X = B for HE matrices
Definition chesvx.f:285
chesv
subroutine chesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
CHESV computes the solution to system of linear equations A * X = B for HE matrices
Definition chesv.f:171
clacpy
subroutine clacpy(uplo, m, n, a, lda, b, ldb)
CLACPY copies all or part of one two-dimensional array to another.
Definition clacpy.f:103
claset
subroutine claset(uplo, m, n, alpha, beta, a, lda)
CLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition claset.f:106
clarhs
subroutine clarhs(path, xtype, uplo, trans, m, n, kl, ku, nrhs, a, lda, x, ldx, b, ldb, iseed, info)
CLARHS
Definition clarhs.f:208
cerrvx
subroutine cerrvx(path, nunit)
CERRVX
Definition cerrvx.f:55
claipd
subroutine claipd(n, a, inda, vinda)
CLAIPD
Definition claipd.f:83
chet01
subroutine chet01(uplo, n, a, lda, afac, ldafac, ipiv, c, ldc, rwork, resid)
CHET01
Definition chet01.f:126
cdrvhe
subroutine cdrvhe(dotype, nn, nval, nrhs, thresh, tsterr, nmax, a, afac, ainv, b, x, xact, work, rwork, iwork, nout)
CDRVHE
Definition cdrvhe.f:153
cpot05
subroutine cpot05(uplo, n, nrhs, a, lda, b, ldb, x, ldx, xact, ldxact, ferr, berr, reslts)
CPOT05
Definition cpot05.f:165
clatb4
subroutine clatb4(path, imat, m, n, type, kl, ku, anorm, mode, cndnum, dist)
CLATB4
Definition clatb4.f:121
cpot02
subroutine cpot02(uplo, n, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
CPOT02
Definition cpot02.f:127
cget04
subroutine cget04(n, nrhs, x, ldx, xact, ldxact, rcond, resid)
CGET04
Definition cget04.f:102
clatms
subroutine clatms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda, work, info)
CLATMS
Definition clatms.f:332
min
#define min(a, b)
Definition macros.h:20
max
#define max(a, b)
Definition macros.h:21