LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ zerrge()

subroutine zerrge ( character*3  path,
integer  nunit 
)

ZERRGEX

Purpose:
 ZERRGE tests the error exits for the COMPLEX*16 routines
 for general matrices.

 Note that this file is used only when the XBLAS are available,
 otherwise zerrge.f defines this subroutine.
Parameters
[in]PATH
          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.
[in]NUNIT
          NUNIT is INTEGER
          The unit number for output.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 57 of file zerrgex.f.

58*
59* -- LAPACK test routine --
60* -- LAPACK is a software package provided by Univ. of Tennessee, --
61* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
62*
63* .. Scalar Arguments ..
64 CHARACTER*3 PATH
65 INTEGER NUNIT
66* ..
67*
68* =====================================================================
69*
70* .. Parameters ..
71 INTEGER NMAX
72 parameter( nmax = 4 )
73* ..
74* .. Local Scalars ..
75 CHARACTER EQ
76 CHARACTER*2 C2
77 INTEGER I, INFO, J, N_ERR_BNDS, NPARAMS
78 DOUBLE PRECISION ANRM, CCOND, RCOND, BERR
79* ..
80* .. Local Arrays ..
81 INTEGER IP( NMAX )
82 DOUBLE PRECISION R( NMAX ), R1( NMAX ), R2( NMAX ), CS( NMAX ),
83 $ RS( NMAX )
84 COMPLEX*16 A( NMAX, NMAX ), AF( NMAX, NMAX ), B( NMAX ),
85 $ W( 2*NMAX ), X( NMAX ), ERR_BNDS_N( NMAX, 3 ),
86 $ ERR_BNDS_C( NMAX, 3 ), PARAMS
87* ..
88* .. External Functions ..
89 LOGICAL LSAMEN
90 EXTERNAL lsamen
91* ..
92* .. External Subroutines ..
93 EXTERNAL alaesm, chkxer, zgbcon, zgbequ, zgbrfs, zgbtf2,
94 $ zgbtrf, zgbtrs, zgecon, zgeequ, zgerfs, zgetf2,
95 $ zgetrf, zgetri, zgetrs, zgeequb, zgerfsx,
96 $ zgbequb, zgbrfsx
97* ..
98* .. Scalars in Common ..
99 LOGICAL LERR, OK
100 CHARACTER*32 SRNAMT
101 INTEGER INFOT, NOUT
102* ..
103* .. Common blocks ..
104 COMMON / infoc / infot, nout, ok, lerr
105 COMMON / srnamc / srnamt
106* ..
107* .. Intrinsic Functions ..
108 INTRINSIC dble, dcmplx
109* ..
110* .. Executable Statements ..
111*
112 nout = nunit
113 WRITE( nout, fmt = * )
114 c2 = path( 2: 3 )
115*
116* Set the variables to innocuous values.
117*
118 DO 20 j = 1, nmax
119 DO 10 i = 1, nmax
120 a( i, j ) = dcmplx( 1.d0 / dble( i+j ),
121 $ -1.d0 / dble( i+j ) )
122 af( i, j ) = dcmplx( 1.d0 / dble( i+j ),
123 $ -1.d0 / dble( i+j ) )
124 10 CONTINUE
125 b( j ) = 0.d0
126 r1( j ) = 0.d0
127 r2( j ) = 0.d0
128 w( j ) = 0.d0
129 x( j ) = 0.d0
130 cs( j ) = 0.d0
131 rs( j ) = 0.d0
132 ip( j ) = j
133 20 CONTINUE
134 ok = .true.
135*
136* Test error exits of the routines that use the LU decomposition
137* of a general matrix.
138*
139 IF( lsamen( 2, c2, 'GE' ) ) THEN
140*
141* ZGETRF
142*
143 srnamt = 'ZGETRF'
144 infot = 1
145 CALL zgetrf( -1, 0, a, 1, ip, info )
146 CALL chkxer( 'ZGETRF', infot, nout, lerr, ok )
147 infot = 2
148 CALL zgetrf( 0, -1, a, 1, ip, info )
149 CALL chkxer( 'ZGETRF', infot, nout, lerr, ok )
150 infot = 4
151 CALL zgetrf( 2, 1, a, 1, ip, info )
152 CALL chkxer( 'ZGETRF', infot, nout, lerr, ok )
153*
154* ZGETF2
155*
156 srnamt = 'ZGETF2'
157 infot = 1
158 CALL zgetf2( -1, 0, a, 1, ip, info )
159 CALL chkxer( 'ZGETF2', infot, nout, lerr, ok )
160 infot = 2
161 CALL zgetf2( 0, -1, a, 1, ip, info )
162 CALL chkxer( 'ZGETF2', infot, nout, lerr, ok )
163 infot = 4
164 CALL zgetf2( 2, 1, a, 1, ip, info )
165 CALL chkxer( 'ZGETF2', infot, nout, lerr, ok )
166*
167* ZGETRI
168*
169 srnamt = 'ZGETRI'
170 infot = 1
171 CALL zgetri( -1, a, 1, ip, w, 1, info )
172 CALL chkxer( 'ZGETRI', infot, nout, lerr, ok )
173 infot = 3
174 CALL zgetri( 2, a, 1, ip, w, 2, info )
175 CALL chkxer( 'ZGETRI', infot, nout, lerr, ok )
176 infot = 6
177 CALL zgetri( 2, a, 2, ip, w, 1, info )
178 CALL chkxer( 'ZGETRI', infot, nout, lerr, ok )
179*
180* ZGETRS
181*
182 srnamt = 'ZGETRS'
183 infot = 1
184 CALL zgetrs( '/', 0, 0, a, 1, ip, b, 1, info )
185 CALL chkxer( 'ZGETRS', infot, nout, lerr, ok )
186 infot = 2
187 CALL zgetrs( 'N', -1, 0, a, 1, ip, b, 1, info )
188 CALL chkxer( 'ZGETRS', infot, nout, lerr, ok )
189 infot = 3
190 CALL zgetrs( 'N', 0, -1, a, 1, ip, b, 1, info )
191 CALL chkxer( 'ZGETRS', infot, nout, lerr, ok )
192 infot = 5
193 CALL zgetrs( 'N', 2, 1, a, 1, ip, b, 2, info )
194 CALL chkxer( 'ZGETRS', infot, nout, lerr, ok )
195 infot = 8
196 CALL zgetrs( 'N', 2, 1, a, 2, ip, b, 1, info )
197 CALL chkxer( 'ZGETRS', infot, nout, lerr, ok )
198*
199* ZGERFS
200*
201 srnamt = 'ZGERFS'
202 infot = 1
203 CALL zgerfs( '/', 0, 0, a, 1, af, 1, ip, b, 1, x, 1, r1, r2, w,
204 $ r, info )
205 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
206 infot = 2
207 CALL zgerfs( 'N', -1, 0, a, 1, af, 1, ip, b, 1, x, 1, r1, r2,
208 $ w, r, info )
209 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
210 infot = 3
211 CALL zgerfs( 'N', 0, -1, a, 1, af, 1, ip, b, 1, x, 1, r1, r2,
212 $ w, r, info )
213 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
214 infot = 5
215 CALL zgerfs( 'N', 2, 1, a, 1, af, 2, ip, b, 2, x, 2, r1, r2, w,
216 $ r, info )
217 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
218 infot = 7
219 CALL zgerfs( 'N', 2, 1, a, 2, af, 1, ip, b, 2, x, 2, r1, r2, w,
220 $ r, info )
221 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
222 infot = 10
223 CALL zgerfs( 'N', 2, 1, a, 2, af, 2, ip, b, 1, x, 2, r1, r2, w,
224 $ r, info )
225 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
226 infot = 12
227 CALL zgerfs( 'N', 2, 1, a, 2, af, 2, ip, b, 2, x, 1, r1, r2, w,
228 $ r, info )
229 CALL chkxer( 'ZGERFS', infot, nout, lerr, ok )
230*
231* ZGERFSX
232*
233 n_err_bnds = 3
234 nparams = 0
235 srnamt = 'ZGERFSX'
236 infot = 1
237 CALL zgerfsx( '/', eq, 0, 0, a, 1, af, 1, ip, rs, cs, b, 1, x,
238 $ 1, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
239 $ nparams, params, w, r, info )
240 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
241 infot = 2
242 eq = '/'
243 CALL zgerfsx( 'N', eq, 2, 1, a, 1, af, 2, ip, rs, cs, b, 2, x,
244 $ 2, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
245 $ nparams, params, w, r, info )
246 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
247 infot = 3
248 eq = 'R'
249 CALL zgerfsx( 'N', eq, -1, 0, a, 1, af, 1, ip, rs, cs, b, 1, x,
250 $ 1, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
251 $ nparams, params, w, r, info )
252 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
253 infot = 4
254 CALL zgerfsx( 'N', eq, 0, -1, a, 1, af, 1, ip, rs, cs, b, 1, x,
255 $ 1, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
256 $ nparams, params, w, r, info )
257 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
258 infot = 6
259 CALL zgerfsx( 'N', eq, 2, 1, a, 1, af, 2, ip, rs, cs, b, 2, x,
260 $ 2, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
261 $ nparams, params, w, r, info )
262 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
263 infot = 8
264 CALL zgerfsx( 'N', eq, 2, 1, a, 2, af, 1, ip, rs, cs, b, 2, x,
265 $ 2, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
266 $ nparams, params, w, r, info )
267 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
268 infot = 13
269 eq = 'C'
270 CALL zgerfsx( 'N', eq, 2, 1, a, 2, af, 2, ip, rs, cs, b, 1, x,
271 $ 2, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
272 $ nparams, params, w, r, info )
273 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
274 infot = 15
275 CALL zgerfsx( 'N', eq, 2, 1, a, 2, af, 2, ip, rs, cs, b, 2, x,
276 $ 1, rcond, berr, n_err_bnds, err_bnds_n, err_bnds_c,
277 $ nparams, params, w, r, info )
278 CALL chkxer( 'ZGERFSX', infot, nout, lerr, ok )
279*
280* ZGECON
281*
282 srnamt = 'ZGECON'
283 infot = 1
284 CALL zgecon( '/', 0, a, 1, anrm, rcond, w, r, info )
285 CALL chkxer( 'ZGECON', infot, nout, lerr, ok )
286 infot = 2
287 CALL zgecon( '1', -1, a, 1, anrm, rcond, w, r, info )
288 CALL chkxer( 'ZGECON', infot, nout, lerr, ok )
289 infot = 4
290 CALL zgecon( '1', 2, a, 1, anrm, rcond, w, r, info )
291 CALL chkxer( 'ZGECON', infot, nout, lerr, ok )
292*
293* ZGEEQU
294*
295 srnamt = 'ZGEEQU'
296 infot = 1
297 CALL zgeequ( -1, 0, a, 1, r1, r2, rcond, ccond, anrm, info )
298 CALL chkxer( 'ZGEEQU', infot, nout, lerr, ok )
299 infot = 2
300 CALL zgeequ( 0, -1, a, 1, r1, r2, rcond, ccond, anrm, info )
301 CALL chkxer( 'ZGEEQU', infot, nout, lerr, ok )
302 infot = 4
303 CALL zgeequ( 2, 2, a, 1, r1, r2, rcond, ccond, anrm, info )
304 CALL chkxer( 'ZGEEQU', infot, nout, lerr, ok )
305*
306* ZGEEQUB
307*
308 srnamt = 'ZGEEQUB'
309 infot = 1
310 CALL zgeequb( -1, 0, a, 1, r1, r2, rcond, ccond, anrm, info )
311 CALL chkxer( 'ZGEEQUB', infot, nout, lerr, ok )
312 infot = 2
313 CALL zgeequb( 0, -1, a, 1, r1, r2, rcond, ccond, anrm, info )
314 CALL chkxer( 'ZGEEQUB', infot, nout, lerr, ok )
315 infot = 4
316 CALL zgeequb( 2, 2, a, 1, r1, r2, rcond, ccond, anrm, info )
317 CALL chkxer( 'ZGEEQUB', infot, nout, lerr, ok )
318*
319* Test error exits of the routines that use the LU decomposition
320* of a general band matrix.
321*
322 ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
323*
324* ZGBTRF
325*
326 srnamt = 'ZGBTRF'
327 infot = 1
328 CALL zgbtrf( -1, 0, 0, 0, a, 1, ip, info )
329 CALL chkxer( 'ZGBTRF', infot, nout, lerr, ok )
330 infot = 2
331 CALL zgbtrf( 0, -1, 0, 0, a, 1, ip, info )
332 CALL chkxer( 'ZGBTRF', infot, nout, lerr, ok )
333 infot = 3
334 CALL zgbtrf( 1, 1, -1, 0, a, 1, ip, info )
335 CALL chkxer( 'ZGBTRF', infot, nout, lerr, ok )
336 infot = 4
337 CALL zgbtrf( 1, 1, 0, -1, a, 1, ip, info )
338 CALL chkxer( 'ZGBTRF', infot, nout, lerr, ok )
339 infot = 6
340 CALL zgbtrf( 2, 2, 1, 1, a, 3, ip, info )
341 CALL chkxer( 'ZGBTRF', infot, nout, lerr, ok )
342*
343* ZGBTF2
344*
345 srnamt = 'ZGBTF2'
346 infot = 1
347 CALL zgbtf2( -1, 0, 0, 0, a, 1, ip, info )
348 CALL chkxer( 'ZGBTF2', infot, nout, lerr, ok )
349 infot = 2
350 CALL zgbtf2( 0, -1, 0, 0, a, 1, ip, info )
351 CALL chkxer( 'ZGBTF2', infot, nout, lerr, ok )
352 infot = 3
353 CALL zgbtf2( 1, 1, -1, 0, a, 1, ip, info )
354 CALL chkxer( 'ZGBTF2', infot, nout, lerr, ok )
355 infot = 4
356 CALL zgbtf2( 1, 1, 0, -1, a, 1, ip, info )
357 CALL chkxer( 'ZGBTF2', infot, nout, lerr, ok )
358 infot = 6
359 CALL zgbtf2( 2, 2, 1, 1, a, 3, ip, info )
360 CALL chkxer( 'ZGBTF2', infot, nout, lerr, ok )
361*
362* ZGBTRS
363*
364 srnamt = 'ZGBTRS'
365 infot = 1
366 CALL zgbtrs( '/', 0, 0, 0, 1, a, 1, ip, b, 1, info )
367 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
368 infot = 2
369 CALL zgbtrs( 'N', -1, 0, 0, 1, a, 1, ip, b, 1, info )
370 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
371 infot = 3
372 CALL zgbtrs( 'N', 1, -1, 0, 1, a, 1, ip, b, 1, info )
373 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
374 infot = 4
375 CALL zgbtrs( 'N', 1, 0, -1, 1, a, 1, ip, b, 1, info )
376 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
377 infot = 5
378 CALL zgbtrs( 'N', 1, 0, 0, -1, a, 1, ip, b, 1, info )
379 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
380 infot = 7
381 CALL zgbtrs( 'N', 2, 1, 1, 1, a, 3, ip, b, 2, info )
382 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
383 infot = 10
384 CALL zgbtrs( 'N', 2, 0, 0, 1, a, 1, ip, b, 1, info )
385 CALL chkxer( 'ZGBTRS', infot, nout, lerr, ok )
386*
387* ZGBRFS
388*
389 srnamt = 'ZGBRFS'
390 infot = 1
391 CALL zgbrfs( '/', 0, 0, 0, 0, a, 1, af, 1, ip, b, 1, x, 1, r1,
392 $ r2, w, r, info )
393 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
394 infot = 2
395 CALL zgbrfs( 'N', -1, 0, 0, 0, a, 1, af, 1, ip, b, 1, x, 1, r1,
396 $ r2, w, r, info )
397 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
398 infot = 3
399 CALL zgbrfs( 'N', 1, -1, 0, 0, a, 1, af, 1, ip, b, 1, x, 1, r1,
400 $ r2, w, r, info )
401 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
402 infot = 4
403 CALL zgbrfs( 'N', 1, 0, -1, 0, a, 1, af, 1, ip, b, 1, x, 1, r1,
404 $ r2, w, r, info )
405 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
406 infot = 5
407 CALL zgbrfs( 'N', 1, 0, 0, -1, a, 1, af, 1, ip, b, 1, x, 1, r1,
408 $ r2, w, r, info )
409 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
410 infot = 7
411 CALL zgbrfs( 'N', 2, 1, 1, 1, a, 2, af, 4, ip, b, 2, x, 2, r1,
412 $ r2, w, r, info )
413 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
414 infot = 9
415 CALL zgbrfs( 'N', 2, 1, 1, 1, a, 3, af, 3, ip, b, 2, x, 2, r1,
416 $ r2, w, r, info )
417 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
418 infot = 12
419 CALL zgbrfs( 'N', 2, 0, 0, 1, a, 1, af, 1, ip, b, 1, x, 2, r1,
420 $ r2, w, r, info )
421 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
422 infot = 14
423 CALL zgbrfs( 'N', 2, 0, 0, 1, a, 1, af, 1, ip, b, 2, x, 1, r1,
424 $ r2, w, r, info )
425 CALL chkxer( 'ZGBRFS', infot, nout, lerr, ok )
426*
427* ZGBRFSX
428*
429 n_err_bnds = 3
430 nparams = 0
431 srnamt = 'ZGBRFSX'
432 infot = 1
433 CALL zgbrfsx( '/', eq, 0, 0, 0, 0, a, 1, af, 1, ip, rs, cs, b,
434 $ 1, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
435 $ err_bnds_c, nparams, params, w, r, info )
436 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
437 infot = 2
438 eq = '/'
439 CALL zgbrfsx( 'N', eq, 2, 1, 1, 1, a, 1, af, 2, ip, rs, cs, b,
440 $ 2, x, 2, rcond, berr, n_err_bnds, err_bnds_n,
441 $ err_bnds_c, nparams, params, w, r, info )
442 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
443 infot = 3
444 eq = 'R'
445 CALL zgbrfsx( 'N', eq, -1, 1, 1, 0, a, 1, af, 1, ip, rs, cs, b,
446 $ 1, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
447 $ err_bnds_c, nparams, params, w, r, info )
448 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
449 infot = 4
450 eq = 'R'
451 CALL zgbrfsx( 'N', eq, 2, -1, 1, 1, a, 3, af, 4, ip, rs, cs, b,
452 $ 1, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
453 $ err_bnds_c, nparams, params, w, r, info )
454 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
455 infot = 5
456 eq = 'R'
457 CALL zgbrfsx( 'N', eq, 2, 1, -1, 1, a, 3, af, 4, ip, rs, cs, b,
458 $ 1, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
459 $ err_bnds_c, nparams, params, w, r, info )
460 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
461 infot = 6
462 CALL zgbrfsx( 'N', eq, 0, 0, 0, -1, a, 1, af, 1, ip, rs, cs, b,
463 $ 1, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
464 $ err_bnds_c, nparams, params, w, r, info )
465 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
466 infot = 8
467 CALL zgbrfsx( 'N', eq, 2, 1, 1, 1, a, 1, af, 2, ip, rs, cs, b,
468 $ 2, x, 2, rcond, berr, n_err_bnds, err_bnds_n,
469 $ err_bnds_c, nparams, params, w, r, info )
470 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
471 infot = 10
472 CALL zgbrfsx( 'N', eq, 2, 1, 1, 1, a, 3, af, 3, ip, rs, cs, b,
473 $ 2, x, 2, rcond, berr, n_err_bnds, err_bnds_n,
474 $ err_bnds_c, nparams, params, w, r, info )
475 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
476 infot = 13
477 eq = 'C'
478 CALL zgbrfsx( 'N', eq, 2, 1, 1, 1, a, 3, af, 5, ip, rs, cs, b,
479 $ 1, x, 2, rcond, berr, n_err_bnds, err_bnds_n,
480 $ err_bnds_c, nparams, params, w, r, info )
481 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
482 infot = 15
483 CALL zgbrfsx( 'N', eq, 2, 1, 1, 1, a, 3, af, 5, ip, rs, cs, b,
484 $ 2, x, 1, rcond, berr, n_err_bnds, err_bnds_n,
485 $ err_bnds_c, nparams, params, w, r, info )
486 CALL chkxer( 'ZGBRFSX', infot, nout, lerr, ok )
487*
488* ZGBCON
489*
490 srnamt = 'ZGBCON'
491 infot = 1
492 CALL zgbcon( '/', 0, 0, 0, a, 1, ip, anrm, rcond, w, r, info )
493 CALL chkxer( 'ZGBCON', infot, nout, lerr, ok )
494 infot = 2
495 CALL zgbcon( '1', -1, 0, 0, a, 1, ip, anrm, rcond, w, r, info )
496 CALL chkxer( 'ZGBCON', infot, nout, lerr, ok )
497 infot = 3
498 CALL zgbcon( '1', 1, -1, 0, a, 1, ip, anrm, rcond, w, r, info )
499 CALL chkxer( 'ZGBCON', infot, nout, lerr, ok )
500 infot = 4
501 CALL zgbcon( '1', 1, 0, -1, a, 1, ip, anrm, rcond, w, r, info )
502 CALL chkxer( 'ZGBCON', infot, nout, lerr, ok )
503 infot = 6
504 CALL zgbcon( '1', 2, 1, 1, a, 3, ip, anrm, rcond, w, r, info )
505 CALL chkxer( 'ZGBCON', infot, nout, lerr, ok )
506*
507* ZGBEQU
508*
509 srnamt = 'ZGBEQU'
510 infot = 1
511 CALL zgbequ( -1, 0, 0, 0, a, 1, r1, r2, rcond, ccond, anrm,
512 $ info )
513 CALL chkxer( 'ZGBEQU', infot, nout, lerr, ok )
514 infot = 2
515 CALL zgbequ( 0, -1, 0, 0, a, 1, r1, r2, rcond, ccond, anrm,
516 $ info )
517 CALL chkxer( 'ZGBEQU', infot, nout, lerr, ok )
518 infot = 3
519 CALL zgbequ( 1, 1, -1, 0, a, 1, r1, r2, rcond, ccond, anrm,
520 $ info )
521 CALL chkxer( 'ZGBEQU', infot, nout, lerr, ok )
522 infot = 4
523 CALL zgbequ( 1, 1, 0, -1, a, 1, r1, r2, rcond, ccond, anrm,
524 $ info )
525 CALL chkxer( 'ZGBEQU', infot, nout, lerr, ok )
526 infot = 6
527 CALL zgbequ( 2, 2, 1, 1, a, 2, r1, r2, rcond, ccond, anrm,
528 $ info )
529 CALL chkxer( 'ZGBEQU', infot, nout, lerr, ok )
530*
531* ZGBEQUB
532*
533 srnamt = 'ZGBEQUB'
534 infot = 1
535 CALL zgbequb( -1, 0, 0, 0, a, 1, r1, r2, rcond, ccond, anrm,
536 $ info )
537 CALL chkxer( 'ZGBEQUB', infot, nout, lerr, ok )
538 infot = 2
539 CALL zgbequb( 0, -1, 0, 0, a, 1, r1, r2, rcond, ccond, anrm,
540 $ info )
541 CALL chkxer( 'ZGBEQUB', infot, nout, lerr, ok )
542 infot = 3
543 CALL zgbequb( 1, 1, -1, 0, a, 1, r1, r2, rcond, ccond, anrm,
544 $ info )
545 CALL chkxer( 'ZGBEQUB', infot, nout, lerr, ok )
546 infot = 4
547 CALL zgbequb( 1, 1, 0, -1, a, 1, r1, r2, rcond, ccond, anrm,
548 $ info )
549 CALL chkxer( 'ZGBEQUB', infot, nout, lerr, ok )
550 infot = 6
551 CALL zgbequb( 2, 2, 1, 1, a, 2, r1, r2, rcond, ccond, anrm,
552 $ info )
553 CALL chkxer( 'ZGBEQUB', infot, nout, lerr, ok )
554 END IF
555*
556* Print a summary line.
557*
558 CALL alaesm( path, ok, nout )
559*
560 RETURN
561*
562* End of ZERRGEX
563*
alaesm
subroutine alaesm(path, ok, nout)
ALAESM
Definition alaesm.f:63
chkxer
subroutine chkxer(srnamt, infot, nout, lerr, ok)
Definition cblat2.f:3224
zgbcon
subroutine zgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)
ZGBCON
Definition zgbcon.f:147
zgbequ
subroutine zgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)
ZGBEQU
Definition zgbequ.f:154
zgbequb
subroutine zgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)
ZGBEQUB
Definition zgbequb.f:161
zgbrfs
subroutine zgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
ZGBRFS
Definition zgbrfs.f:206
zgbrfsx
subroutine zgbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, info)
ZGBRFSX
Definition zgbrfsx.f:440
zgbtf2
subroutine zgbtf2(m, n, kl, ku, ab, ldab, ipiv, info)
ZGBTF2 computes the LU factorization of a general band matrix using the unblocked version of the algo...
Definition zgbtf2.f:145
zgbtrf
subroutine zgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)
ZGBTRF
Definition zgbtrf.f:144
zgbtrs
subroutine zgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
ZGBTRS
Definition zgbtrs.f:138
zgecon
subroutine zgecon(norm, n, a, lda, anorm, rcond, work, rwork, info)
ZGECON
Definition zgecon.f:132
zgeequ
subroutine zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)
ZGEEQU
Definition zgeequ.f:140
zgeequb
subroutine zgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)
ZGEEQUB
Definition zgeequb.f:147
zgerfs
subroutine zgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
ZGERFS
Definition zgerfs.f:186
zgerfsx
subroutine zgerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, info)
ZGERFSX
Definition zgerfsx.f:414
zgetf2
subroutine zgetf2(m, n, a, lda, ipiv, info)
ZGETF2 computes the LU factorization of a general m-by-n matrix using partial pivoting with row inter...
Definition zgetf2.f:108
zgetrf
subroutine zgetrf(m, n, a, lda, ipiv, info)
ZGETRF
Definition zgetrf.f:108
zgetri
subroutine zgetri(n, a, lda, ipiv, work, lwork, info)
ZGETRI
Definition zgetri.f:114
zgetrs
subroutine zgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)
ZGETRS
Definition zgetrs.f:121
lsamen
logical function lsamen(n, ca, cb)
LSAMEN
Definition lsamen.f:74
Here is the call graph for this function: