LAPACK  3.10.1
LAPACK: Linear Algebra PACKage
zerrgex.f
Go to the documentation of this file.
1 *> \brief \b ZERRGEX
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 ZERRGE( PATH, NUNIT )
12 *
13 * .. Scalar Arguments ..
14 * CHARACTER*3 PATH
15 * INTEGER NUNIT
16 * ..
17 *
18 *
19 *> \par Purpose:
20 * =============
21 *>
22 *> \verbatim
23 *>
24 *> ZERRGE tests the error exits for the COMPLEX*16 routines
25 *> for general matrices.
26 *>
27 *> Note that this file is used only when the XBLAS are available,
28 *> otherwise zerrge.f defines this subroutine.
29 *> \endverbatim
30 *
31 * Arguments:
32 * ==========
33 *
34 *> \param[in] PATH
35 *> \verbatim
36 *> PATH is CHARACTER*3
37 *> The LAPACK path name for the routines to be tested.
38 *> \endverbatim
39 *>
40 *> \param[in] NUNIT
41 *> \verbatim
42 *> NUNIT is INTEGER
43 *> The unit number for output.
44 *> \endverbatim
45 *
46 * Authors:
47 * ========
48 *
49 *> \author Univ. of Tennessee
50 *> \author Univ. of California Berkeley
51 *> \author Univ. of Colorado Denver
52 *> \author NAG Ltd.
53 *
54 *> \ingroup complex16_lin
55 *
56 * =====================================================================
57  SUBROUTINE zerrge( PATH, NUNIT )
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,
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 *
564  END
subroutine chkxer(SRNAMT, INFOT, NOUT, LERR, OK)
Definition: cblat2.f:3196
subroutine alaesm(PATH, OK, NOUT)
ALAESM
Definition: alaesm.f:63
subroutine zerrge(PATH, NUNIT)
ZERRGE
Definition: zerrge.f:55
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
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
subroutine zgbequb(M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, INFO)
ZGBEQUB
Definition: zgbequb.f:161
subroutine zgbcon(NORM, N, KL, KU, AB, LDAB, IPIV, ANORM, RCOND, WORK, RWORK, INFO)
ZGBCON
Definition: zgbcon.f:147
subroutine zgbtrf(M, N, KL, KU, AB, LDAB, IPIV, INFO)
ZGBTRF
Definition: zgbtrf.f:144
subroutine zgbequ(M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, INFO)
ZGBEQU
Definition: zgbequ.f:154
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
subroutine zgbtrs(TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, INFO)
ZGBTRS
Definition: zgbtrs.f:138
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
subroutine zgeequb(M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, INFO)
ZGEEQUB
Definition: zgeequb.f:147
subroutine zgetrs(TRANS, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZGETRS
Definition: zgetrs.f:121
subroutine zgerfs(TRANS, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
ZGERFS
Definition: zgerfs.f:186
subroutine zgeequ(M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, INFO)
ZGEEQU
Definition: zgeequ.f:140
subroutine zgetri(N, A, LDA, IPIV, WORK, LWORK, INFO)
ZGETRI
Definition: zgetri.f:114
subroutine zgecon(NORM, N, A, LDA, ANORM, RCOND, WORK, RWORK, INFO)
ZGECON
Definition: zgecon.f:124
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
subroutine zgetrf(M, N, A, LDA, IPIV, INFO)
ZGETRF VARIANT: Crout Level 3 BLAS version of the algorithm.
Definition: zgetrf.f:102