LAPACK  3.6.0
LAPACK: Linear Algebra PACKage
Collaboration diagram for aux:

Functions

subroutine aladhd (IOUNIT, PATH)
 ALADHD More...
 
subroutine alaerh (PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
 ALAERH More...
 
subroutine alaesm (PATH, OK, NOUT)
 ALAESM More...
 
subroutine alahd (IOUNIT, PATH)
 ALAHD More...
 
subroutine alareq (PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT)
 ALAREQ More...
 
subroutine alasum (TYPE, NOUT, NFAIL, NRUN, NERRS)
 ALASUM More...
 
subroutine alasvm (TYPE, NOUT, NFAIL, NRUN, NERRS)
 ALASVM More...
 
subroutine icopy (N, SX, INCX, SY, INCY)
 ICOPY More...
 
integer function ilaenv (ISPEC, NAME, OPTS, N1, N2, N3, N4)
 ILAENV More...
 
subroutine xlaenv (ISPEC, NVALUE)
 XLAENV More...
 

Detailed Description

This is the group of auxiliary LAPACK TESTING LIN routines.

Function Documentation

subroutine aladhd ( integer  IOUNIT,
character*3  PATH 
)

ALADHD

Purpose:
 ALADHD prints header information for the driver routines test paths.
Parameters
[in]IOUNIT
          IOUNIT is INTEGER
          The unit number to which the header information should be
          printed.
[in]PATH
          PATH is CHARACTER*3
          The name of the path for which the header information is to
          be printed.  Current paths are
             _GE:  General matrices
             _GB:  General band
             _GT:  General Tridiagonal
             _PO:  Symmetric or Hermitian positive definite
             _PS:  Symmetric or Hermitian positive semi-definite
             _PP:  Symmetric or Hermitian positive definite packed
             _PB:  Symmetric or Hermitian positive definite band
             _PT:  Symmetric or Hermitian positive definite tridiagonal
             _SY:  Symmetric indefinite,
                     with partial (Bunch-Kaufman) pivoting
             _SR:  Symmetric indefinite,
                     with "rook" (bounded Bunch-Kaufman) pivoting
             _SP:  Symmetric indefinite packed,
                     with partial (Bunch-Kaufman) pivoting
             _HE:  (complex) Hermitian indefinite,
                     with partial (Bunch-Kaufman) pivoting
             _HR:  (complex) Hermitian indefinite,
                     with "rook" (bounded Bunch-Kaufman) pivoting
             _HP:  (complex) Hermitian indefinite packed,
                     with partial (Bunch-Kaufman) pivoting
          The first character must be one of S, D, C, or Z (C or Z only
          if complex).
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2013

Definition at line 80 of file aladhd.f.

80 *
81 * -- LAPACK test routine (version 3.5.0) --
82 * -- LAPACK is a software package provided by Univ. of Tennessee, --
83 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
84 * November 2013
85 *
86 * .. Scalar Arguments ..
87  CHARACTER*3 path
88  INTEGER iounit
89 * ..
90 *
91 * =====================================================================
92 *
93 * .. Local Scalars ..
94  LOGICAL corz, sord
95  CHARACTER c1, c3
96  CHARACTER*2 p2
97  CHARACTER*9 sym
98 * ..
99 * .. External Functions ..
100  LOGICAL lsame, lsamen
101  EXTERNAL lsame, lsamen
102 * ..
103 * .. Executable Statements ..
104 *
105  IF( iounit.LE.0 )
106  $ RETURN
107  c1 = path( 1: 1 )
108  c3 = path( 3: 3 )
109  p2 = path( 2: 3 )
110  sord = lsame( c1, 'S' ) .OR. lsame( c1, 'D' )
111  corz = lsame( c1, 'C' ) .OR. lsame( c1, 'Z' )
112  IF( .NOT.( sord .OR. corz ) )
113  $ RETURN
114 *
115  IF( lsamen( 2, p2, 'GE' ) ) THEN
116 *
117 * GE: General dense
118 *
119  WRITE( iounit, fmt = 9999 )path
120  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
121  WRITE( iounit, fmt = 9989 )
122  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
123  WRITE( iounit, fmt = 9981 )1
124  WRITE( iounit, fmt = 9980 )2
125  WRITE( iounit, fmt = 9979 )3
126  WRITE( iounit, fmt = 9978 )4
127  WRITE( iounit, fmt = 9977 )5
128  WRITE( iounit, fmt = 9976 )6
129  WRITE( iounit, fmt = 9972 )7
130  WRITE( iounit, fmt = '( '' Messages:'' )' )
131 *
132  ELSE IF( lsamen( 2, p2, 'GB' ) ) THEN
133 *
134 * GB: General band
135 *
136  WRITE( iounit, fmt = 9998 )path
137  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
138  WRITE( iounit, fmt = 9988 )
139  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
140  WRITE( iounit, fmt = 9981 )1
141  WRITE( iounit, fmt = 9980 )2
142  WRITE( iounit, fmt = 9979 )3
143  WRITE( iounit, fmt = 9978 )4
144  WRITE( iounit, fmt = 9977 )5
145  WRITE( iounit, fmt = 9976 )6
146  WRITE( iounit, fmt = 9972 )7
147  WRITE( iounit, fmt = '( '' Messages:'' )' )
148 *
149  ELSE IF( lsamen( 2, p2, 'GT' ) ) THEN
150 *
151 * GT: General tridiagonal
152 *
153  WRITE( iounit, fmt = 9997 )path
154  WRITE( iounit, fmt = 9987 )
155  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
156  WRITE( iounit, fmt = 9981 )1
157  WRITE( iounit, fmt = 9980 )2
158  WRITE( iounit, fmt = 9979 )3
159  WRITE( iounit, fmt = 9978 )4
160  WRITE( iounit, fmt = 9977 )5
161  WRITE( iounit, fmt = 9976 )6
162  WRITE( iounit, fmt = '( '' Messages:'' )' )
163 *
164  ELSE IF( lsamen( 2, p2, 'PO' ) .OR. lsamen( 2, p2, 'PP' )
165  $ .OR. lsamen( 2, p2, 'PS' ) ) THEN
166 *
167 * PO: Positive definite full
168 * PS: Positive definite full
169 * PP: Positive definite packed
170 *
171  IF( sord ) THEN
172  sym = 'Symmetric'
173  ELSE
174  sym = 'Hermitian'
175  END IF
176  IF( lsame( c3, 'O' ) ) THEN
177  WRITE( iounit, fmt = 9996 )path, sym
178  ELSE
179  WRITE( iounit, fmt = 9995 )path, sym
180  END IF
181  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
182  WRITE( iounit, fmt = 9985 )path
183  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
184  WRITE( iounit, fmt = 9975 )1
185  WRITE( iounit, fmt = 9980 )2
186  WRITE( iounit, fmt = 9979 )3
187  WRITE( iounit, fmt = 9978 )4
188  WRITE( iounit, fmt = 9977 )5
189  WRITE( iounit, fmt = 9976 )6
190  WRITE( iounit, fmt = '( '' Messages:'' )' )
191 *
192  ELSE IF( lsamen( 2, p2, 'PB' ) ) THEN
193 *
194 * PB: Positive definite band
195 *
196  IF( sord ) THEN
197  WRITE( iounit, fmt = 9994 )path, 'Symmetric'
198  ELSE
199  WRITE( iounit, fmt = 9994 )path, 'Hermitian'
200  END IF
201  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
202  WRITE( iounit, fmt = 9984 )path
203  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
204  WRITE( iounit, fmt = 9975 )1
205  WRITE( iounit, fmt = 9980 )2
206  WRITE( iounit, fmt = 9979 )3
207  WRITE( iounit, fmt = 9978 )4
208  WRITE( iounit, fmt = 9977 )5
209  WRITE( iounit, fmt = 9976 )6
210  WRITE( iounit, fmt = '( '' Messages:'' )' )
211 *
212  ELSE IF( lsamen( 2, p2, 'PT' ) ) THEN
213 *
214 * PT: Positive definite tridiagonal
215 *
216  IF( sord ) THEN
217  WRITE( iounit, fmt = 9993 )path, 'Symmetric'
218  ELSE
219  WRITE( iounit, fmt = 9993 )path, 'Hermitian'
220  END IF
221  WRITE( iounit, fmt = 9986 )
222  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
223  WRITE( iounit, fmt = 9973 )1
224  WRITE( iounit, fmt = 9980 )2
225  WRITE( iounit, fmt = 9979 )3
226  WRITE( iounit, fmt = 9978 )4
227  WRITE( iounit, fmt = 9977 )5
228  WRITE( iounit, fmt = 9976 )6
229  WRITE( iounit, fmt = '( '' Messages:'' )' )
230 *
231  ELSE IF( lsamen( 2, p2, 'SY' ) .OR. lsamen( 2, p2, 'SP' ) ) THEN
232 *
233 * SY: Symmetric indefinite full
234 * with partial (Bunch-Kaufman) pivoting algorithm
235 * SP: Symmetric indefinite packed
236 * with partial (Bunch-Kaufman) pivoting algorithm
237 *
238  IF( lsame( c3, 'Y' ) ) THEN
239  WRITE( iounit, fmt = 9992 )path, 'Symmetric'
240  ELSE
241  WRITE( iounit, fmt = 9991 )path, 'Symmetric'
242  END IF
243  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
244  IF( sord ) THEN
245  WRITE( iounit, fmt = 9983 )
246  ELSE
247  WRITE( iounit, fmt = 9982 )
248  END IF
249  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
250  WRITE( iounit, fmt = 9974 )1
251  WRITE( iounit, fmt = 9980 )2
252  WRITE( iounit, fmt = 9979 )3
253  WRITE( iounit, fmt = 9977 )4
254  WRITE( iounit, fmt = 9978 )5
255  WRITE( iounit, fmt = 9976 )6
256  WRITE( iounit, fmt = '( '' Messages:'' )' )
257 *
258  ELSE IF( lsamen( 2, p2, 'SR' ) ) THEN
259 *
260 * SR: Symmetric indefinite full,
261 * with "rook" (bounded Bunch-Kaufman) pivoting algorithm
262 *
263  WRITE( iounit, fmt = 9992 )path, 'Symmetric'
264 *
265  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
266  IF( sord ) THEN
267  WRITE( iounit, fmt = 9983 )
268  ELSE
269  WRITE( iounit, fmt = 9982 )
270  END IF
271 *
272  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
273  WRITE( iounit, fmt = 9974 )1
274  WRITE( iounit, fmt = 9980 )2
275  WRITE( iounit, fmt = 9979 )3
276  WRITE( iounit, fmt = '( '' Messages:'' )' )
277 *
278  ELSE IF( lsamen( 2, p2, 'HE' ) .OR. lsamen( 2, p2, 'HP' ) ) THEN
279 *
280 * HE: Hermitian indefinite full
281 * with partial (Bunch-Kaufman) pivoting algorithm
282 * HP: Hermitian indefinite packed
283 * with partial (Bunch-Kaufman) pivoting algorithm
284 *
285  IF( lsame( c3, 'E' ) ) THEN
286  WRITE( iounit, fmt = 9992 )path, 'Hermitian'
287  ELSE
288  WRITE( iounit, fmt = 9991 )path, 'Hermitian'
289  END IF
290 *
291  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
292  WRITE( iounit, fmt = 9983 )
293 *
294  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
295  WRITE( iounit, fmt = 9974 )1
296  WRITE( iounit, fmt = 9980 )2
297  WRITE( iounit, fmt = 9979 )3
298  WRITE( iounit, fmt = 9977 )4
299  WRITE( iounit, fmt = 9978 )5
300  WRITE( iounit, fmt = 9976 )6
301  WRITE( iounit, fmt = '( '' Messages:'' )' )
302 *
303  ELSE IF( lsamen( 2, p2, 'HR' ) ) THEN
304 *
305 * HR: Hermitian indefinite full,
306 * with "rook" (bounded Bunch-Kaufman) pivoting algorithm
307 *
308  WRITE( iounit, fmt = 9992 )path, 'Hermitian'
309 *
310  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
311  WRITE( iounit, fmt = 9983 )
312 *
313  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
314  WRITE( iounit, fmt = 9974 )1
315  WRITE( iounit, fmt = 9980 )2
316  WRITE( iounit, fmt = 9979 )3
317  WRITE( iounit, fmt = '( '' Messages:'' )' )
318 *
319  ELSE
320 *
321 * Print error message if no header is available.
322 *
323  WRITE( iounit, fmt = 9990 )path
324  END IF
325 *
326 * First line of header
327 *
328  9999 FORMAT( / 1x, a3, ' drivers: General dense matrices' )
329  9998 FORMAT( / 1x, a3, ' drivers: General band matrices' )
330  9997 FORMAT( / 1x, a3, ' drivers: General tridiagonal' )
331  9996 FORMAT( / 1x, a3, ' drivers: ', a9,
332  $ ' positive definite matrices' )
333  9995 FORMAT( / 1x, a3, ' drivers: ', a9,
334  $ ' positive definite packed matrices' )
335  9994 FORMAT( / 1x, a3, ' drivers: ', a9,
336  $ ' positive definite band matrices' )
337  9993 FORMAT( / 1x, a3, ' drivers: ', a9,
338  $ ' positive definite tridiagonal' )
339  9992 FORMAT( / 1x, a3, ' drivers: ', a9, ' indefinite matrices',
340  $ ', "rook" (bounded Bunch-Kaufman) pivoting' )
341  9991 FORMAT( / 1x, a3, ' drivers: ', a9,
342  $ ' indefinite packed matrices',
343  $ ', partial (Bunch-Kaufman) pivoting' )
344  9891 FORMAT( / 1x, a3, ' drivers: ', a9,
345  $ ' indefinite packed matrices',
346  $ ', "rook" (bounded Bunch-Kaufman) pivoting' )
347  9990 FORMAT( / 1x, a3, ': No header available' )
348 *
349 * GE matrix types
350 *
351  9989 FORMAT( 4x, '1. Diagonal', 24x, '7. Last n/2 columns zero', / 4x,
352  $ '2. Upper triangular', 16x,
353  $ '8. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
354  $ '3. Lower triangular', 16x, '9. Random, CNDNUM = 0.1/EPS',
355  $ / 4x, '4. Random, CNDNUM = 2', 13x,
356  $ '10. Scaled near underflow', / 4x, '5. First column zero',
357  $ 14x, '11. Scaled near overflow', / 4x,
358  $ '6. Last column zero' )
359 *
360 * GB matrix types
361 *
362  9988 FORMAT( 4x, '1. Random, CNDNUM = 2', 14x,
363  $ '5. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
364  $ '2. First column zero', 15x, '6. Random, CNDNUM = 0.1/EPS',
365  $ / 4x, '3. Last column zero', 16x,
366  $ '7. Scaled near underflow', / 4x,
367  $ '4. Last n/2 columns zero', 11x, '8. Scaled near overflow' )
368 *
369 * GT matrix types
370 *
371  9987 FORMAT( ' Matrix types (1-6 have specified condition numbers):',
372  $ / 4x, '1. Diagonal', 24x, '7. Random, unspecified CNDNUM',
373  $ / 4x, '2. Random, CNDNUM = 2', 14x, '8. First column zero',
374  $ / 4x, '3. Random, CNDNUM = sqrt(0.1/EPS)', 2x,
375  $ '9. Last column zero', / 4x, '4. Random, CNDNUM = 0.1/EPS',
376  $ 7x, '10. Last n/2 columns zero', / 4x,
377  $ '5. Scaled near underflow', 10x,
378  $ '11. Scaled near underflow', / 4x,
379  $ '6. Scaled near overflow', 11x, '12. Scaled near overflow' )
380 *
381 * PT matrix types
382 *
383  9986 FORMAT( ' Matrix types (1-6 have specified condition numbers):',
384  $ / 4x, '1. Diagonal', 24x, '7. Random, unspecified CNDNUM',
385  $ / 4x, '2. Random, CNDNUM = 2', 14x,
386  $ '8. First row and column zero', / 4x,
387  $ '3. Random, CNDNUM = sqrt(0.1/EPS)', 2x,
388  $ '9. Last row and column zero', / 4x,
389  $ '4. Random, CNDNUM = 0.1/EPS', 7x,
390  $ '10. Middle row and column zero', / 4x,
391  $ '5. Scaled near underflow', 10x,
392  $ '11. Scaled near underflow', / 4x,
393  $ '6. Scaled near overflow', 11x, '12. Scaled near overflow' )
394 *
395 * PO, PP matrix types
396 *
397  9985 FORMAT( 4x, '1. Diagonal', 24x,
398  $ '6. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
399  $ '2. Random, CNDNUM = 2', 14x, '7. Random, CNDNUM = 0.1/EPS',
400  $ / 3x, '*3. First row and column zero', 7x,
401  $ '8. Scaled near underflow', / 3x,
402  $ '*4. Last row and column zero', 8x,
403  $ '9. Scaled near overflow', / 3x,
404  $ '*5. Middle row and column zero', / 3x,
405  $ '(* - tests error exits from ', a3,
406  $ 'TRF, no test ratios are computed)' )
407 *
408 * PB matrix types
409 *
410  9984 FORMAT( 4x, '1. Random, CNDNUM = 2', 14x,
411  $ '5. Random, CNDNUM = sqrt(0.1/EPS)', / 3x,
412  $ '*2. First row and column zero', 7x,
413  $ '6. Random, CNDNUM = 0.1/EPS', / 3x,
414  $ '*3. Last row and column zero', 8x,
415  $ '7. Scaled near underflow', / 3x,
416  $ '*4. Middle row and column zero', 6x,
417  $ '8. Scaled near overflow', / 3x,
418  $ '(* - tests error exits from ', a3,
419  $ 'TRF, no test ratios are computed)' )
420 *
421 * SSY, SSP, CHE, CHP matrix types
422 *
423  9983 FORMAT( 4x, '1. Diagonal', 24x,
424  $ '6. Last n/2 rows and columns zero', / 4x,
425  $ '2. Random, CNDNUM = 2', 14x,
426  $ '7. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
427  $ '3. First row and column zero', 7x,
428  $ '8. Random, CNDNUM = 0.1/EPS', / 4x,
429  $ '4. Last row and column zero', 8x,
430  $ '9. Scaled near underflow', / 4x,
431  $ '5. Middle row and column zero', 5x,
432  $ '10. Scaled near overflow' )
433 *
434 * CSY, CSP matrix types
435 *
436  9982 FORMAT( 4x, '1. Diagonal', 24x,
437  $ '7. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
438  $ '2. Random, CNDNUM = 2', 14x, '8. Random, CNDNUM = 0.1/EPS',
439  $ / 4x, '3. First row and column zero', 7x,
440  $ '9. Scaled near underflow', / 4x,
441  $ '4. Last row and column zero', 7x,
442  $ '10. Scaled near overflow', / 4x,
443  $ '5. Middle row and column zero', 5x,
444  $ '11. Block diagonal matrix', / 4x,
445  $ '6. Last n/2 rows and columns zero' )
446 *
447 * Test ratios
448 *
449  9981 FORMAT( 3x, i2, ': norm( L * U - A ) / ( N * norm(A) * EPS )' )
450  9980 FORMAT( 3x, i2, ': norm( B - A * X ) / ',
451  $ '( norm(A) * norm(X) * EPS )' )
452  9979 FORMAT( 3x, i2, ': norm( X - XACT ) / ',
453  $ '( norm(XACT) * CNDNUM * EPS )' )
454  9978 FORMAT( 3x, i2, ': norm( X - XACT ) / ',
455  $ '( norm(XACT) * (error bound) )' )
456  9977 FORMAT( 3x, i2, ': (backward error) / EPS' )
457  9976 FORMAT( 3x, i2, ': RCOND * CNDNUM - 1.0' )
458  9975 FORMAT( 3x, i2, ': norm( U'' * U - A ) / ( N * norm(A) * EPS )',
459  $ ', or', / 7x, 'norm( L * L'' - A ) / ( N * norm(A) * EPS )'
460  $ )
461  9974 FORMAT( 3x, i2, ': norm( U*D*U'' - A ) / ( N * norm(A) * EPS )',
462  $ ', or', / 7x, 'norm( L*D*L'' - A ) / ( N * norm(A) * EPS )'
463  $ )
464  9973 FORMAT( 3x, i2, ': norm( U''*D*U - A ) / ( N * norm(A) * EPS )',
465  $ ', or', / 7x, 'norm( L*D*L'' - A ) / ( N * norm(A) * EPS )'
466  $ )
467  9972 FORMAT( 3x, i2, ': abs( WORK(1) - RPVGRW ) /',
468  $ ' ( max( WORK(1), RPVGRW ) * EPS )' )
469 *
470  RETURN
471 *
472 * End of ALADHD
473 *
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
logical function lsamen(N, CA, CB)
LSAMEN
Definition: lsamen.f:76
subroutine alaerh ( character*3  PATH,
character*( * )  SUBNAM,
integer  INFO,
integer  INFOE,
character*( * )  OPTS,
integer  M,
integer  N,
integer  KL,
integer  KU,
integer  N5,
integer  IMAT,
integer  NFAIL,
integer  NERRS,
integer  NOUT 
)

ALAERH

Purpose:
 ALAERH is an error handler for the LAPACK routines.  It prints the
 header if this is the first error message and prints the error code
 and form of recovery, if any.  The character evaluations in this
 routine may make it slow, but it should not be called once the LAPACK
 routines are fully debugged.
Parameters
[in]PATH
          PATH is CHARACTER*3
          The LAPACK path name of subroutine SUBNAM.
[in]SUBNAM
          SUBNAM is CHARACTER*(*)
          The name of the subroutine that returned an error code.
[in]INFO
          INFO is INTEGER
          The error code returned from routine SUBNAM.
[in]INFOE
          INFOE is INTEGER
          The expected error code from routine SUBNAM, if SUBNAM were
          error-free.  If INFOE = 0, an error message is printed, but
          if INFOE.NE.0, we assume only the return code INFO is wrong.
[in]OPTS
          OPTS is CHARACTER*(*)
          The character options to the subroutine SUBNAM, concatenated
          into a single character string.  For example, UPLO = 'U',
          TRANS = 'T', and DIAG = 'N' for a triangular routine would
          be specified as OPTS = 'UTN'.
[in]M
          M is INTEGER
          The matrix row dimension.
[in]N
          N is INTEGER
          The matrix column dimension.  Accessed only if PATH = xGE or
          xGB.
[in]KL
          KL is INTEGER
          The number of sub-diagonals of the matrix.  Accessed only if
          PATH = xGB, xPB, or xTB.  Also used for NRHS for PATH = xLS.
[in]KU
          KU is INTEGER
          The number of super-diagonals of the matrix.  Accessed only
          if PATH = xGB.
[in]N5
          N5 is INTEGER
          A fifth integer parameter, may be the blocksize NB or the
          number of right hand sides NRHS.
[in]IMAT
          IMAT is INTEGER
          The matrix type.
[in]NFAIL
          NFAIL is INTEGER
          The number of prior tests that did not pass the threshold;
          used to determine if the header should be printed.
[in,out]NERRS
          NERRS is INTEGER
          On entry, the number of errors already detected; used to
          determine if the header should be printed.
          On exit, NERRS is increased by 1.
[in]NOUT
          NOUT is INTEGER
          The unit number on which results are to be printed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2013

Definition at line 149 of file alaerh.f.

149 *
150 * -- LAPACK test routine (version 3.5.0) --
151 * -- LAPACK is a software package provided by Univ. of Tennessee, --
152 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
153 * November 2013
154 *
155 * .. Scalar Arguments ..
156  CHARACTER*3 path
157  CHARACTER*( * ) subnam
158  CHARACTER*( * ) opts
159  INTEGER imat, info, infoe, kl, ku, m, n, n5, nerrs,
160  $ nfail, nout
161 * ..
162 *
163 * =====================================================================
164 *
165 * .. Local Scalars ..
166  CHARACTER uplo
167  CHARACTER*2 p2
168  CHARACTER*3 c3
169 * ..
170 * .. External Functions ..
171  LOGICAL lsame, lsamen
172  EXTERNAL lsame, lsamen
173 * ..
174 * .. Intrinsic Functions ..
175  INTRINSIC len_trim
176 * ..
177 * .. External Subroutines ..
178  EXTERNAL aladhd, alahd
179 * ..
180 * .. Executable Statements ..
181 *
182  IF( info.EQ.0 )
183  $ RETURN
184  p2 = path( 2: 3 )
185  c3 = subnam( 4: 6 )
186 *
187 * Print the header if this is the first error message.
188 *
189  IF( nfail.EQ.0 .AND. nerrs.EQ.0 ) THEN
190  IF( lsamen( 3, c3, 'SV ' ) .OR. lsamen( 3, c3, 'SVX' ) ) THEN
191  CALL aladhd( nout, path )
192  ELSE
193  CALL alahd( nout, path )
194  END IF
195  END IF
196  nerrs = nerrs + 1
197 *
198 * Print the message detailing the error and form of recovery,
199 * if any.
200 *
201  IF( lsamen( 2, p2, 'GE' ) ) THEN
202 *
203 * xGE: General matrices
204 *
205  IF( lsamen( 3, c3, 'TRF' ) ) THEN
206  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
207  WRITE( nout, fmt = 9988 )
208  $ subnam(1:len_trim( subnam )), info, infoe, m, n, n5,
209  $ imat
210  ELSE
211  WRITE( nout, fmt = 9975 )
212  $ subnam(1:len_trim( subnam )), info, m, n, n5, imat
213  END IF
214  IF( info.NE.0 )
215  $ WRITE( nout, fmt = 9949 )
216 *
217  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
218 *
219  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
220  WRITE( nout, fmt = 9984 )
221  $ subnam(1:len_trim( subnam )), info, infoe, n, n5,
222  $ imat
223  ELSE
224  WRITE( nout, fmt = 9970 )
225  $ subnam(1:len_trim( subnam )), info, n, n5, imat
226  END IF
227 *
228  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
229 *
230  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
231  WRITE( nout, fmt = 9992 )
232  $ subnam(1:len_trim( subnam )), info, infoe,
233  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
234  ELSE
235  WRITE( nout, fmt = 9997 )
236  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
237  $ opts( 2: 2 ), n, n5, imat
238  END IF
239 *
240  ELSE IF( lsamen( 3, c3, 'TRI' ) ) THEN
241 *
242  WRITE( nout, fmt = 9971 )
243  $ subnam(1:len_trim( subnam )), info, n, n5, imat
244 *
245  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
246 *
247  WRITE( nout, fmt = 9978 )
248  $ subnam(1:len_trim( subnam )), info, m, n, imat
249 *
250  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
251 *
252  WRITE( nout, fmt = 9969 )
253  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m,
254  $ imat
255 *
256  ELSE IF( lsamen( 3, c3, 'LS ' ) ) THEN
257 *
258  WRITE( nout, fmt = 9965 )
259  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, n,
260  $ kl, n5, imat
261 *
262  ELSE IF( lsamen( 3, c3, 'LSX' ) .OR. lsamen( 3, c3, 'LSS' ) )
263  $ THEN
264 *
265  WRITE( nout, fmt = 9974 )
266  $ subnam(1:len_trim( subnam )), info, m, n, kl, n5, imat
267 *
268  ELSE
269 *
270  WRITE( nout, fmt = 9963 )
271  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, n5,
272  $ imat
273  END IF
274 *
275  ELSE IF( lsamen( 2, p2, 'GB' ) ) THEN
276 *
277 * xGB: General band matrices
278 *
279  IF( lsamen( 3, c3, 'TRF' ) ) THEN
280  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
281  WRITE( nout, fmt = 9989 )
282  $ subnam(1:len_trim( subnam )), info, infoe, m, n, kl,
283  $ ku, n5, imat
284  ELSE
285  WRITE( nout, fmt = 9976 )
286  $ subnam(1:len_trim( subnam )), info, m, n, kl, ku, n5,
287  $ imat
288  END IF
289  IF( info.NE.0 )
290  $ WRITE( nout, fmt = 9949 )
291 *
292  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
293 *
294  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
295  WRITE( nout, fmt = 9986 )
296  $ subnam(1:len_trim( subnam )), info, infoe, n, kl, ku,
297  $ n5, imat
298  ELSE
299  WRITE( nout, fmt = 9972 )
300  $ subnam(1:len_trim( subnam )), info, n, kl, ku, n5,
301  $ imat
302  END IF
303 *
304  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
305 *
306  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
307  WRITE( nout, fmt = 9993 )
308  $ subnam(1:len_trim( subnam )), info, infoe,
309  $ opts( 1: 1 ), opts( 2: 2 ), n, kl, ku, n5, imat
310  ELSE
311  WRITE( nout, fmt = 9998 )
312  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
313  $ opts( 2: 2 ), n, kl, ku, n5, imat
314  END IF
315 *
316  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
317 *
318  WRITE( nout, fmt = 9977 )
319  $ subnam(1:len_trim( subnam )), info, m, n, kl, ku, imat
320 *
321  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
322 *
323  WRITE( nout, fmt = 9968 )
324  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, kl,
325  $ ku, imat
326 *
327  ELSE
328 *
329  WRITE( nout, fmt = 9964 )
330  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, kl,
331  $ ku, n5, imat
332  END IF
333 *
334  ELSE IF( lsamen( 2, p2, 'GT' ) ) THEN
335 *
336 * xGT: General tridiagonal matrices
337 *
338  IF( lsamen( 3, c3, 'TRF' ) ) THEN
339  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
340  WRITE( nout, fmt = 9987 )
341  $ subnam(1:len_trim( subnam )), info, infoe, n, imat
342  ELSE
343  WRITE( nout, fmt = 9973 )
344  $ subnam(1:len_trim( subnam )), info, n, imat
345  END IF
346  IF( info.NE.0 )
347  $ WRITE( nout, fmt = 9949 )
348 *
349  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
350 *
351  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
352  WRITE( nout, fmt = 9984 )
353  $ subnam(1:len_trim( subnam )), info, infoe, n, n5,
354  $ imat
355  ELSE
356  WRITE( nout, fmt = 9970 )
357  $ subnam(1:len_trim( subnam )), info, n, n5, imat
358  END IF
359 *
360  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
361 *
362  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
363  WRITE( nout, fmt = 9992 )
364  $ subnam(1:len_trim( subnam )), info, infoe,
365  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
366  ELSE
367  WRITE( nout, fmt = 9997 )
368  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
369  $ opts( 2: 2 ), n, n5, imat
370  END IF
371 *
372  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
373 *
374  WRITE( nout, fmt = 9969 )
375  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m,
376  $ imat
377 *
378  ELSE
379 *
380  WRITE( nout, fmt = 9963 )
381  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, n5,
382  $ imat
383  END IF
384 *
385  ELSE IF( lsamen( 2, p2, 'PO' ) ) THEN
386 *
387 * xPO: Symmetric or Hermitian positive definite matrices
388 *
389  uplo = opts( 1: 1 )
390  IF( lsamen( 3, c3, 'TRF' ) ) THEN
391  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
392  WRITE( nout, fmt = 9980 )
393  $ subnam(1:len_trim( subnam )), info, infoe, uplo, m,
394  $ n5, imat
395  ELSE
396  WRITE( nout, fmt = 9956 )
397  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
398  END IF
399  IF( info.NE.0 )
400  $ WRITE( nout, fmt = 9949 )
401 *
402  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
403 *
404  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
405  WRITE( nout, fmt = 9979 )
406  $ subnam(1:len_trim( subnam )), info, infoe, uplo, n,
407  $ n5, imat
408  ELSE
409  WRITE( nout, fmt = 9955 )
410  $ subnam(1:len_trim( subnam )), info, uplo, n, n5, imat
411  END IF
412 *
413  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
414 *
415  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
416  WRITE( nout, fmt = 9990 )
417  $ subnam(1:len_trim( subnam )), info, infoe,
418  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
419  ELSE
420  WRITE( nout, fmt = 9995 )
421  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
422  $ opts( 2: 2 ), n, n5, imat
423  END IF
424 *
425  ELSE IF( lsamen( 3, c3, 'TRI' ) ) THEN
426 *
427  WRITE( nout, fmt = 9956 )
428  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
429 *
430  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) .OR.
431  $ lsamen( 3, c3, 'CON' ) ) THEN
432 *
433  WRITE( nout, fmt = 9960 )
434  $ subnam(1:len_trim( subnam )), info, uplo, m, imat
435 *
436  ELSE
437 *
438  WRITE( nout, fmt = 9955 )
439  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
440  END IF
441 *
442  ELSE IF( lsamen( 2, p2, 'PS' ) ) THEN
443 *
444 * xPS: Symmetric or Hermitian positive semi-definite matrices
445 *
446  uplo = opts( 1: 1 )
447  IF( lsamen( 3, c3, 'TRF' ) ) THEN
448  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
449  WRITE( nout, fmt = 9980 )subnam, info, infoe, uplo, m,
450  $ n5, imat
451  ELSE
452  WRITE( nout, fmt = 9956 )subnam, info, uplo, m, n5, imat
453  END IF
454  IF( info.NE.0 )
455  $ WRITE( nout, fmt = 9949 )
456 *
457  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
458 *
459  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
460  WRITE( nout, fmt = 9979 )subnam, info, infoe, uplo, n,
461  $ n5, imat
462  ELSE
463  WRITE( nout, fmt = 9955 )subnam, info, uplo, n, n5, imat
464  END IF
465 *
466  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
467 *
468  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
469  WRITE( nout, fmt = 9990 )subnam, info, infoe,
470  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
471  ELSE
472  WRITE( nout, fmt = 9995 )subnam, info, opts( 1: 1 ),
473  $ opts( 2: 2 ), n, n5, imat
474  END IF
475 *
476  ELSE IF( lsamen( 3, c3, 'TRI' ) ) THEN
477 *
478  WRITE( nout, fmt = 9956 )subnam, info, uplo, m, n5, imat
479 *
480  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMT' ) .OR.
481  $ lsamen( 3, c3, 'CON' ) ) THEN
482 *
483  WRITE( nout, fmt = 9960 )subnam, info, uplo, m, imat
484 *
485  ELSE
486 *
487  WRITE( nout, fmt = 9955 )subnam, info, uplo, m, n5, imat
488  END IF
489 *
490  ELSE IF( lsamen( 2, p2, 'SY' )
491  $ .OR. lsamen( 2, p2, 'SR' )
492  $ .OR. lsamen( 2, p2, 'HE' )
493  $ .OR. lsamen( 2, p2, 'HR' ) ) THEN
494 *
495 * xSY: symmetric indefinite matrices
496 * with partial (Bunch-Kaufman) pivoting;
497 * xSR: symmetric indefinite matrices
498 * with rook (bounded Bunch-Kaufman) pivoting;
499 * xHE: Hermitian indefinite matrices
500 * with partial (Bunch-Kaufman) pivoting.
501 * xHR: Hermitian indefinite matrices
502 * with rook (bounded Bunch-Kaufman) pivoting;
503 *
504  uplo = opts( 1: 1 )
505  IF( lsamen( 3, c3, 'TRF' ) ) THEN
506  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
507  WRITE( nout, fmt = 9980 )
508  $ subnam(1:len_trim( subnam )), info, infoe, uplo, m,
509  $ n5, imat
510  ELSE
511  WRITE( nout, fmt = 9956 )
512  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
513  END IF
514  IF( info.NE.0 )
515  $ WRITE( nout, fmt = 9949 )
516 *
517  ELSE IF( lsamen( 2, c3, 'SV' ) ) THEN
518 *
519  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
520  WRITE( nout, fmt = 9979 )
521  $ subnam(1:len_trim( subnam )), info, infoe, uplo, n,
522  $ n5, imat
523  ELSE
524  WRITE( nout, fmt = 9955 )
525  $ subnam(1:len_trim( subnam )), info, uplo, n, n5, imat
526  END IF
527 *
528  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
529 *
530  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
531  WRITE( nout, fmt = 9990 )
532  $ subnam(1:len_trim( subnam )), info, infoe,
533  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
534  ELSE
535  WRITE( nout, fmt = 9995 )
536  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
537  $ opts( 2: 2 ), n, n5, imat
538  END IF
539 *
540  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) .OR.
541  $ lsamen( 3, c3, 'TRI' ) .OR. lsamen( 3, c3, 'CON' ) )
542  $ THEN
543 *
544  WRITE( nout, fmt = 9960 )
545  $ subnam(1:len_trim( subnam )), info, uplo, m, imat
546 *
547  ELSE
548 *
549  WRITE( nout, fmt = 9955 )
550  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
551  END IF
552 *
553  ELSE IF( lsamen( 2, p2, 'PP' ) .OR. lsamen( 2, p2, 'SP' ) .OR.
554  $ lsamen( 2, p2, 'HP' ) ) THEN
555 *
556 * xPP, xHP, or xSP: Symmetric or Hermitian packed matrices
557 *
558  uplo = opts( 1: 1 )
559  IF( lsamen( 3, c3, 'TRF' ) ) THEN
560  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
561  WRITE( nout, fmt = 9983 )
562  $ subnam(1:len_trim( subnam )), info, infoe, uplo, m,
563  $ imat
564  ELSE
565  WRITE( nout, fmt = 9960 )
566  $ subnam(1:len_trim( subnam )), info, uplo, m, imat
567  END IF
568  IF( info.NE.0 )
569  $ WRITE( nout, fmt = 9949 )
570 *
571  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
572 *
573  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
574  WRITE( nout, fmt = 9979 )
575  $ subnam(1:len_trim( subnam )), info, infoe, uplo, n,
576  $ n5, imat
577  ELSE
578  WRITE( nout, fmt = 9955 )
579  $ subnam(1:len_trim( subnam )), info, uplo, n, n5, imat
580  END IF
581 *
582  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
583 *
584  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
585  WRITE( nout, fmt = 9990 )
586  $ subnam(1:len_trim( subnam )), info, infoe,
587  $ opts( 1: 1 ), opts( 2: 2 ), n, n5, imat
588  ELSE
589  WRITE( nout, fmt = 9995 )
590  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
591  $ opts( 2: 2 ), n, n5, imat
592  END IF
593 *
594  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) .OR.
595  $ lsamen( 3, c3, 'TRI' ) .OR. lsamen( 3, c3, 'CON' ) )
596  $ THEN
597 *
598  WRITE( nout, fmt = 9960 )
599  $ subnam(1:len_trim( subnam )), info, uplo, m, imat
600 *
601  ELSE
602 *
603  WRITE( nout, fmt = 9955 )
604  $ subnam(1:len_trim( subnam )), info, uplo, m, n5, imat
605  END IF
606 *
607  ELSE IF( lsamen( 2, p2, 'PB' ) ) THEN
608 *
609 * xPB: Symmetric (Hermitian) positive definite band matrix
610 *
611  uplo = opts( 1: 1 )
612  IF( lsamen( 3, c3, 'TRF' ) ) THEN
613  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
614  WRITE( nout, fmt = 9982 )
615  $ subnam(1:len_trim( subnam )), info, infoe, uplo, m,
616  $ kl, n5, imat
617  ELSE
618  WRITE( nout, fmt = 9958 )
619  $ subnam(1:len_trim( subnam )), info, uplo, m, kl, n5,
620  $ imat
621  END IF
622  IF( info.NE.0 )
623  $ WRITE( nout, fmt = 9949 )
624 *
625  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
626 *
627  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
628  WRITE( nout, fmt = 9981 )
629  $ subnam(1:len_trim( subnam )), info, infoe, uplo, n,
630  $ kl, n5, imat
631  ELSE
632  WRITE( nout, fmt = 9957 )
633  $ subnam(1:len_trim( subnam )), info, uplo, n, kl, n5,
634  $ imat
635  END IF
636 *
637  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
638 *
639  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
640  WRITE( nout, fmt = 9991 )
641  $ subnam(1:len_trim( subnam )), info, infoe,
642  $ opts( 1: 1 ), opts( 2: 2 ), n, kl, n5, imat
643  ELSE
644  WRITE( nout, fmt = 9996 )
645  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
646  $ opts( 2: 2 ), n, kl, n5, imat
647  END IF
648 *
649  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) .OR.
650  $ lsamen( 3, c3, 'CON' ) ) THEN
651 *
652  WRITE( nout, fmt = 9959 )
653  $ subnam(1:len_trim( subnam )), info, uplo, m, kl, imat
654 *
655  ELSE
656 *
657  WRITE( nout, fmt = 9957 )
658  $ subnam(1:len_trim( subnam )), info, uplo, m, kl, n5,
659  $ imat
660  END IF
661 *
662  ELSE IF( lsamen( 2, p2, 'PT' ) ) THEN
663 *
664 * xPT: Positive definite tridiagonal matrices
665 *
666  IF( lsamen( 3, c3, 'TRF' ) ) THEN
667  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
668  WRITE( nout, fmt = 9987 )
669  $ subnam(1:len_trim( subnam )), info, infoe, n, imat
670  ELSE
671  WRITE( nout, fmt = 9973 )
672  $ subnam(1:len_trim( subnam )), info, n, imat
673  END IF
674  IF( info.NE.0 )
675  $ WRITE( nout, fmt = 9949 )
676 *
677  ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
678 *
679  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
680  WRITE( nout, fmt = 9984 )
681  $ subnam(1:len_trim( subnam )), info, infoe, n, n5,
682  $ imat
683  ELSE
684  WRITE( nout, fmt = 9970 )
685  $ subnam(1:len_trim( subnam )), info, n, n5, imat
686  END IF
687 *
688  ELSE IF( lsamen( 3, c3, 'SVX' ) ) THEN
689 *
690  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
691  WRITE( nout, fmt = 9994 )
692  $ subnam(1:len_trim( subnam )), info, infoe,
693  $ opts( 1: 1 ), n, n5, imat
694  ELSE
695  WRITE( nout, fmt = 9999 )
696  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), n,
697  $ n5, imat
698  END IF
699 *
700  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
701 *
702  IF( lsame( subnam( 1: 1 ), 'S' ) .OR.
703  $ lsame( subnam( 1: 1 ), 'D' ) ) THEN
704  WRITE( nout, fmt = 9973 )
705  $ subnam(1:len_trim( subnam )), info, m, imat
706  ELSE
707  WRITE( nout, fmt = 9969 )
708  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m,
709  $ imat
710  END IF
711 *
712  ELSE
713 *
714  WRITE( nout, fmt = 9963 )
715  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ), m, n5,
716  $ imat
717  END IF
718 *
719  ELSE IF( lsamen( 2, p2, 'TR' ) ) THEN
720 *
721 * xTR: Triangular matrix
722 *
723  IF( lsamen( 3, c3, 'TRI' ) ) THEN
724  WRITE( nout, fmt = 9961 )
725  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
726  $ opts( 2: 2 ), m, n5, imat
727  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
728  WRITE( nout, fmt = 9967 )
729  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
730  $ opts( 2: 2 ), opts( 3: 3 ), m, imat
731  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATRS' ) ) THEN
732  WRITE( nout, fmt = 9952 )
733  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
734  $ opts( 2: 2 ), opts( 3: 3 ), opts( 4: 4 ), m, imat
735  ELSE
736  WRITE( nout, fmt = 9953 )
737  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
738  $ opts( 2: 2 ), opts( 3: 3 ), m, n5, imat
739  END IF
740 *
741  ELSE IF( lsamen( 2, p2, 'TP' ) ) THEN
742 *
743 * xTP: Triangular packed matrix
744 *
745  IF( lsamen( 3, c3, 'TRI' ) ) THEN
746  WRITE( nout, fmt = 9962 )
747  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
748  $ opts( 2: 2 ), m, imat
749  ELSE IF( lsamen( 3, c3, 'CON' ) ) THEN
750  WRITE( nout, fmt = 9967 )
751  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
752  $ opts( 2: 2 ), opts( 3: 3 ), m, imat
753  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATPS' ) ) THEN
754  WRITE( nout, fmt = 9952 )
755  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
756  $ opts( 2: 2 ), opts( 3: 3 ), opts( 4: 4 ), m, imat
757  ELSE
758  WRITE( nout, fmt = 9953 )
759  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
760  $ opts( 2: 2 ), opts( 3: 3 ), m, n5, imat
761  END IF
762 *
763  ELSE IF( lsamen( 2, p2, 'TB' ) ) THEN
764 *
765 * xTB: Triangular band matrix
766 *
767  IF( lsamen( 3, c3, 'CON' ) ) THEN
768  WRITE( nout, fmt = 9966 )
769  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
770  $ opts( 2: 2 ), opts( 3: 3 ), m, kl, imat
771  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATBS' ) ) THEN
772  WRITE( nout, fmt = 9951 )
773  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
774  $ opts( 2: 2 ), opts( 3: 3 ), opts( 4: 4 ), m, kl, imat
775  ELSE
776  WRITE( nout, fmt = 9954 )
777  $ subnam(1:len_trim( subnam )), info, opts( 1: 1 ),
778  $ opts( 2: 2 ), opts( 3: 3 ), m, kl, n5, imat
779  END IF
780 *
781  ELSE IF( lsamen( 2, p2, 'QR' ) ) THEN
782 *
783 * xQR: QR factorization
784 *
785  IF( lsamen( 3, c3, 'QRS' ) ) THEN
786  WRITE( nout, fmt = 9974 )
787  $ subnam(1:len_trim( subnam )), info, m, n, kl, n5, imat
788  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
789  WRITE( nout, fmt = 9978 )
790  $ subnam(1:len_trim( subnam )), info, m, n, imat
791  END IF
792 *
793  ELSE IF( lsamen( 2, p2, 'LQ' ) ) THEN
794 *
795 * xLQ: LQ factorization
796 *
797  IF( lsamen( 3, c3, 'LQS' ) ) THEN
798  WRITE( nout, fmt = 9974 )
799  $ subnam(1:len_trim( subnam )), info, m, n, kl, n5, imat
800  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
801  WRITE( nout, fmt = 9978 )
802  $ subnam(1:len_trim( subnam )), info, m, n, imat
803  END IF
804 *
805  ELSE IF( lsamen( 2, p2, 'QL' ) ) THEN
806 *
807 * xQL: QL factorization
808 *
809  IF( lsamen( 3, c3, 'QLS' ) ) THEN
810  WRITE( nout, fmt = 9974 )
811  $ subnam(1:len_trim( subnam )), info, m, n, kl, n5, imat
812  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
813  WRITE( nout, fmt = 9978 )
814  $ subnam(1:len_trim( subnam )), info, m, n, imat
815  END IF
816 *
817  ELSE IF( lsamen( 2, p2, 'RQ' ) ) THEN
818 *
819 * xRQ: RQ factorization
820 *
821  IF( lsamen( 3, c3, 'RQS' ) ) THEN
822  WRITE( nout, fmt = 9974 )
823  $ subnam(1:len_trim( subnam )), info, m, n, kl, n5, imat
824  ELSE IF( lsamen( 5, subnam( 2: 6 ), 'LATMS' ) ) THEN
825  WRITE( nout, fmt = 9978 )
826  $ subnam(1:len_trim( subnam )), info, m, n, imat
827  END IF
828 *
829  ELSE IF( lsamen( 2, p2, 'LU' ) ) THEN
830 *
831  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
832  WRITE( nout, fmt = 9988 )
833  $ subnam(1:len_trim( subnam )), info, infoe, m, n, n5,
834  $ imat
835  ELSE
836  WRITE( nout, fmt = 9975 )
837  $ subnam(1:len_trim( subnam )), info, m, n, n5, imat
838  END IF
839 *
840  ELSE IF( lsamen( 2, p2, 'CH' ) ) THEN
841 *
842  IF( info.NE.infoe .AND. infoe.NE.0 ) THEN
843  WRITE( nout, fmt = 9985 )
844  $ subnam(1:len_trim( subnam )), info, infoe, m, n5, imat
845  ELSE
846  WRITE( nout, fmt = 9971 )
847  $ subnam(1:len_trim( subnam )), info, m, n5, imat
848  END IF
849 *
850  ELSE
851 *
852 * Print a generic message if the path is unknown.
853 *
854  WRITE( nout, fmt = 9950 )
855  $ subnam(1:len_trim( subnam )), info
856  END IF
857 *
858 * Description of error message (alphabetical, left to right)
859 *
860 * SUBNAM, INFO, FACT, N, NRHS, IMAT
861 *
862  9999 FORMAT( ' *** Error code from ', a, '=', i5, ', FACT=''', a1,
863  $ ''', N=', i5, ', NRHS=', i4, ', type ', i2 )
864 *
865 * SUBNAM, INFO, FACT, TRANS, N, KL, KU, NRHS, IMAT
866 *
867  9998 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> FACT=''',
868  $ a1, ''', TRANS=''', a1, ''', N=', i5, ', KL=', i5, ', KU=',
869  $ i5, ', NRHS=', i4, ', type ', i1 )
870 *
871 * SUBNAM, INFO, FACT, TRANS, N, NRHS, IMAT
872 *
873  9997 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> FACT=''',
874  $ a1, ''', TRANS=''', a1, ''', N =', i5, ', NRHS =', i4,
875  $ ', type ', i2 )
876 *
877 * SUBNAM, INFO, FACT, UPLO, N, KD, NRHS, IMAT
878 *
879  9996 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> FACT=''',
880  $ a1, ''', UPLO=''', a1, ''', N=', i5, ', KD=', i5, ', NRHS=',
881  $ i4, ', type ', i2 )
882 *
883 * SUBNAM, INFO, FACT, UPLO, N, NRHS, IMAT
884 *
885  9995 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> FACT=''',
886  $ a1, ''', UPLO=''', a1, ''', N =', i5, ', NRHS =', i4,
887  $ ', type ', i2 )
888 *
889 * SUBNAM, INFO, INFOE, FACT, N, NRHS, IMAT
890 *
891  9994 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
892  $ i2, / ' ==> FACT=''', a1, ''', N =', i5, ', NRHS =', i4,
893  $ ', type ', i2 )
894 *
895 * SUBNAM, INFO, INFOE, FACT, TRANS, N, KL, KU, NRHS, IMAT
896 *
897  9993 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
898  $ i2, / ' ==> FACT=''', a1, ''', TRANS=''', a1, ''', N=', i5,
899  $ ', KL=', i5, ', KU=', i5, ', NRHS=', i4, ', type ', i1 )
900 *
901 * SUBNAM, INFO, INFOE, FACT, TRANS, N, NRHS, IMAT
902 *
903  9992 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
904  $ i2, / ' ==> FACT=''', a1, ''', TRANS=''', a1, ''', N =', i5,
905  $ ', NRHS =', i4, ', type ', i2 )
906 *
907 * SUBNAM, INFO, INFOE, FACT, UPLO, N, KD, NRHS, IMAT
908 *
909  9991 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
910  $ i2, / ' ==> FACT=''', a1, ''', UPLO=''', a1, ''', N=', i5,
911  $ ', KD=', i5, ', NRHS=', i4, ', type ', i2 )
912 *
913 * SUBNAM, INFO, INFOE, FACT, UPLO, N, NRHS, IMAT
914 *
915  9990 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
916  $ i2, / ' ==> FACT=''', a1, ''', UPLO=''', a1, ''', N =', i5,
917  $ ', NRHS =', i4, ', type ', i2 )
918 *
919 * SUBNAM, INFO, INFOE, M, N, KL, KU, NB, IMAT
920 *
921  9989 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
922  $ i2, / ' ==> M = ', i5, ', N =', i5, ', KL =', i5, ', KU =',
923  $ i5, ', NB =', i4, ', type ', i2 )
924 *
925 * SUBNAM, INFO, INFOE, M, N, NB, IMAT
926 *
927  9988 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
928  $ i2, / ' ==> M =', i5, ', N =', i5, ', NB =', i4, ', type ',
929  $ i2 )
930 *
931 * SUBNAM, INFO, INFOE, N, IMAT
932 *
933  9987 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
934  $ i2, ' for N=', i5, ', type ', i2 )
935 *
936 * SUBNAM, INFO, INFOE, N, KL, KU, NRHS, IMAT
937 *
938  9986 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
939  $ i2, / ' ==> N =', i5, ', KL =', i5, ', KU =', i5,
940  $ ', NRHS =', i4, ', type ', i2 )
941 *
942 * SUBNAM, INFO, INFOE, N, NB, IMAT
943 *
944  9985 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
945  $ i2, / ' ==> N =', i5, ', NB =', i4, ', type ', i2 )
946 *
947 * SUBNAM, INFO, INFOE, N, NRHS, IMAT
948 *
949  9984 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
950  $ i2, / ' ==> N =', i5, ', NRHS =', i4, ', type ', i2 )
951 *
952 * SUBNAM, INFO, INFOE, UPLO, N, IMAT
953 *
954  9983 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
955  $ i2, / ' ==> UPLO = ''', a1, ''', N =', i5, ', type ', i2 )
956 *
957 * SUBNAM, INFO, INFOE, UPLO, N, KD, NB, IMAT
958 *
959  9982 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
960  $ i2, / ' ==> UPLO = ''', a1, ''', N =', i5, ', KD =', i5,
961  $ ', NB =', i4, ', type ', i2 )
962 *
963 * SUBNAM, INFO, INFOE, UPLO, N, KD, NRHS, IMAT
964 *
965  9981 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
966  $ i2, / ' ==> UPLO=''', a1, ''', N =', i5, ', KD =', i5,
967  $ ', NRHS =', i4, ', type ', i2 )
968 *
969 * SUBNAM, INFO, INFOE, UPLO, N, NB, IMAT
970 *
971  9980 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
972  $ i2, / ' ==> UPLO = ''', a1, ''', N =', i5, ', NB =', i4,
973  $ ', type ', i2 )
974 *
975 * SUBNAM, INFO, INFOE, UPLO, N, NRHS, IMAT
976 *
977  9979 FORMAT( ' *** ', a, ' returned with INFO =', i5, ' instead of ',
978  $ i2, / ' ==> UPLO = ''', a1, ''', N =', i5, ', NRHS =', i4,
979  $ ', type ', i2 )
980 *
981 * SUBNAM, INFO, M, N, IMAT
982 *
983  9978 FORMAT( ' *** Error code from ', a, ' =', i5, ' for M =', i5,
984  $ ', N =', i5, ', type ', i2 )
985 *
986 * SUBNAM, INFO, M, N, KL, KU, IMAT
987 *
988  9977 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> M = ', i5,
989  $ ', N =', i5, ', KL =', i5, ', KU =', i5, ', type ', i2 )
990 *
991 * SUBNAM, INFO, M, N, KL, KU, NB, IMAT
992 *
993  9976 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> M = ', i5,
994  $ ', N =', i5, ', KL =', i5, ', KU =', i5, ', NB =', i4,
995  $ ', type ', i2 )
996 *
997 * SUBNAM, INFO, M, N, NB, IMAT
998 *
999  9975 FORMAT( ' *** Error code from ', a, '=', i5, ' for M=', i5,
1000  $ ', N=', i5, ', NB=', i4, ', type ', i2 )
1001 *
1002 * SUBNAM, INFO, M, N, NRHS, NB, IMAT
1003 *
1004  9974 FORMAT( ' *** Error code from ', a, '=', i5, / ' ==> M =', i5,
1005  $ ', N =', i5, ', NRHS =', i4, ', NB =', i4, ', type ', i2 )
1006 *
1007 * SUBNAM, INFO, N, IMAT
1008 *
1009  9973 FORMAT( ' *** Error code from ', a, ' =', i5, ' for N =', i5,
1010  $ ', type ', i2 )
1011 *
1012 * SUBNAM, INFO, N, KL, KU, NRHS, IMAT
1013 *
1014  9972 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> N =', i5,
1015  $ ', KL =', i5, ', KU =', i5, ', NRHS =', i4, ', type ', i2 )
1016 *
1017 * SUBNAM, INFO, N, NB, IMAT
1018 *
1019  9971 FORMAT( ' *** Error code from ', a, '=', i5, ' for N=', i5,
1020  $ ', NB=', i4, ', type ', i2 )
1021 *
1022 * SUBNAM, INFO, N, NRHS, IMAT
1023 *
1024  9970 FORMAT( ' *** Error code from ', a, ' =', i5, ' for N =', i5,
1025  $ ', NRHS =', i4, ', type ', i2 )
1026 *
1027 * SUBNAM, INFO, NORM, N, IMAT
1028 *
1029  9969 FORMAT( ' *** Error code from ', a, ' =', i5, ' for NORM = ''',
1030  $ a1, ''', N =', i5, ', type ', i2 )
1031 *
1032 * SUBNAM, INFO, NORM, N, KL, KU, IMAT
1033 *
1034  9968 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> NORM =''',
1035  $ a1, ''', N =', i5, ', KL =', i5, ', KU =', i5, ', type ',
1036  $ i2 )
1037 *
1038 * SUBNAM, INFO, NORM, UPLO, DIAG, N, IMAT
1039 *
1040  9967 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> NORM=''',
1041  $ a1, ''', UPLO =''', a1, ''', DIAG=''', a1, ''', N =', i5,
1042  $ ', type ', i2 )
1043 *
1044 * SUBNAM, INFO, NORM, UPLO, DIAG, N, KD, IMAT
1045 *
1046  9966 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> NORM=''',
1047  $ a1, ''', UPLO =''', a1, ''', DIAG=''', a1, ''', N=', i5,
1048  $ ', KD=', i5, ', type ', i2 )
1049 *
1050 * SUBNAM, INFO, TRANS, M, N, NRHS, NB, IMAT
1051 *
1052  9965 FORMAT( ' *** Error code from ', a, ' =', i5,
1053  $ / ' ==> TRANS = ''', a1, ''', M =', i5, ', N =', i5,
1054  $ ', NRHS =', i4, ', NB =', i4, ', type ', i2 )
1055 *
1056 * SUBNAM, INFO, TRANS, N, KL, KU, NRHS, IMAT
1057 *
1058  9964 FORMAT( ' *** Error code from ', a, '=', i5, / ' ==> TRANS=''',
1059  $ a1, ''', N =', i5, ', KL =', i5, ', KU =', i5, ', NRHS =',
1060  $ i4, ', type ', i2 )
1061 *
1062 * SUBNAM, INFO, TRANS, N, NRHS, IMAT
1063 *
1064  9963 FORMAT( ' *** Error code from ', a, ' =', i5,
1065  $ / ' ==> TRANS = ''', a1, ''', N =', i5, ', NRHS =', i4,
1066  $ ', type ', i2 )
1067 *
1068 * SUBNAM, INFO, UPLO, DIAG, N, IMAT
1069 *
1070  9962 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1071  $ a1, ''', DIAG =''', a1, ''', N =', i5, ', type ', i2 )
1072 *
1073 * SUBNAM, INFO, UPLO, DIAG, N, NB, IMAT
1074 *
1075  9961 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1076  $ a1, ''', DIAG =''', a1, ''', N =', i5, ', NB =', i4,
1077  $ ', type ', i2 )
1078 *
1079 * SUBNAM, INFO, UPLO, N, IMAT
1080 *
1081  9960 FORMAT( ' *** Error code from ', a, ' =', i5, ' for UPLO = ''',
1082  $ a1, ''', N =', i5, ', type ', i2 )
1083 *
1084 * SUBNAM, INFO, UPLO, N, KD, IMAT
1085 *
1086  9959 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO = ''',
1087  $ a1, ''', N =', i5, ', KD =', i5, ', type ', i2 )
1088 *
1089 * SUBNAM, INFO, UPLO, N, KD, NB, IMAT
1090 *
1091  9958 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO = ''',
1092  $ a1, ''', N =', i5, ', KD =', i5, ', NB =', i4, ', type ',
1093  $ i2 )
1094 *
1095 * SUBNAM, INFO, UPLO, N, KD, NRHS, IMAT
1096 *
1097  9957 FORMAT( ' *** Error code from ', a, '=', i5, / ' ==> UPLO = ''',
1098  $ a1, ''', N =', i5, ', KD =', i5, ', NRHS =', i4, ', type ',
1099  $ i2 )
1100 *
1101 * SUBNAM, INFO, UPLO, N, NB, IMAT
1102 *
1103  9956 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO = ''',
1104  $ a1, ''', N =', i5, ', NB =', i4, ', type ', i2 )
1105 *
1106 * SUBNAM, INFO, UPLO, N, NRHS, IMAT
1107 *
1108  9955 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO = ''',
1109  $ a1, ''', N =', i5, ', NRHS =', i4, ', type ', i2 )
1110 *
1111 * SUBNAM, INFO, UPLO, TRANS, DIAG, N, KD, NRHS, IMAT
1112 *
1113  9954 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1114  $ a1, ''', TRANS=''', a1, ''', DIAG=''', a1, ''', N=', i5,
1115  $ ', KD=', i5, ', NRHS=', i4, ', type ', i2 )
1116 *
1117 * SUBNAM, INFO, UPLO, TRANS, DIAG, N, NRHS, IMAT
1118 *
1119  9953 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1120  $ a1, ''', TRANS=''', a1, ''', DIAG=''', a1, ''', N =', i5,
1121  $ ', NRHS =', i4, ', type ', i2 )
1122 *
1123 * SUBNAM, INFO, UPLO, TRANS, DIAG, NORMIN, N, IMAT
1124 *
1125  9952 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1126  $ a1, ''', TRANS=''', a1, ''', DIAG=''', a1, ''', NORMIN=''',
1127  $ a1, ''', N =', i5, ', type ', i2 )
1128 *
1129 * SUBNAM, INFO, UPLO, TRANS, DIAG, NORMIN, N, KD, IMAT
1130 *
1131  9951 FORMAT( ' *** Error code from ', a, ' =', i5, / ' ==> UPLO=''',
1132  $ a1, ''', TRANS=''', a1, ''', DIAG=''', a1, ''', NORMIN=''',
1133  $ a1, ''', N=', i5, ', KD=', i5, ', type ', i2 )
1134 *
1135 * Unknown type
1136 *
1137  9950 FORMAT( ' *** Error code from ', a, ' =', i5 )
1138 *
1139 * What we do next
1140 *
1141  9949 FORMAT( ' ==> Doing only the condition estimate for this case' )
1142 *
1143  RETURN
1144 *
1145 * End of ALAERH
1146 *
subroutine aladhd(IOUNIT, PATH)
ALADHD
Definition: aladhd.f:80
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:95
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
logical function lsamen(N, CA, CB)
LSAMEN
Definition: lsamen.f:76

Here is the call graph for this function:

subroutine alaesm ( character*3  PATH,
logical  OK,
integer  NOUT 
)

ALAESM

Purpose:
 ALAESM prints a summary of results from one of the -ERR- routines.
Parameters
[in]PATH
          PATH is CHARACTER*3
          The LAPACK path name.
[in]OK
          OK is LOGICAL
          The flag from CHKXER that indicates whether or not the tests
          of error exits passed.
[in]NOUT
          NOUT is INTEGER
          The unit number on which results are to be printed.
          NOUT >= 0.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 65 of file alaesm.f.

65 *
66 * -- LAPACK test routine (version 3.4.0) --
67 * -- LAPACK is a software package provided by Univ. of Tennessee, --
68 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
69 * November 2011
70 *
71 * .. Scalar Arguments ..
72  LOGICAL ok
73  CHARACTER*3 path
74  INTEGER nout
75 * ..
76 *
77 * =====================================================================
78 *
79 * .. Executable Statements ..
80 *
81  IF( ok ) THEN
82  WRITE( nout, fmt = 9999 )path
83  ELSE
84  WRITE( nout, fmt = 9998 )path
85  END IF
86 *
87  9999 FORMAT( 1x, a3, ' routines passed the tests of the error exits'
88  $ )
89  9998 FORMAT( ' *** ', a3, ' routines failed the tests of the error ',
90  $ 'exits ***' )
91  RETURN
92 *
93 * End of ALAESM
94 *
subroutine alahd ( integer  IOUNIT,
character*3  PATH 
)

ALAHD

Purpose:
 ALAHD prints header information for the different test paths.
Parameters
[in]IOUNIT
          IOUNIT is INTEGER
          The unit number to which the header information should be
          printed.
[in]PATH
          PATH is CHARACTER*3
          The name of the path for which the header information is to
          be printed.  Current paths are
             _GE:  General matrices
             _GB:  General band
             _GT:  General Tridiagonal
             _PO:  Symmetric or Hermitian positive definite
             _PS:  Symmetric or Hermitian positive semi-definite
             _PP:  Symmetric or Hermitian positive definite packed
             _PB:  Symmetric or Hermitian positive definite band
             _PT:  Symmetric or Hermitian positive definite tridiagonal
             _SY:  Symmetric indefinite,
                     with partial (Bunch-Kaufman) pivoting
             _SR:  Symmetric indefinite,
                     with "rook" (bounded Bunch-Kaufman) pivoting
             _SP:  Symmetric indefinite packed,
                     with partial (Bunch-Kaufman) pivoting
             _HE:  (complex) Hermitian indefinite,
                     with partial (Bunch-Kaufman) pivoting
             _HR:  Symmetric indefinite,
                     with "rook" (bounded Bunch-Kaufman) pivoting
             _HP:  (complex) Hermitian indefinite packed,
                     with partial (Bunch-Kaufman) pivoting
             _TR:  Triangular
             _TP:  Triangular packed
             _TB:  Triangular band
             _QR:  QR (general matrices)
             _LQ:  LQ (general matrices)
             _QL:  QL (general matrices)
             _RQ:  RQ (general matrices)
             _QP:  QR with column pivoting
             _TZ:  Trapezoidal
             _LS:  Least Squares driver routines
             _LU:  LU variants
             _CH:  Cholesky variants
             _QS:  QR variants
             _QT:  QRT (general matrices)
             _QX:  QRT (triangular-pentagonal matrices)
          The first character must be one of S, D, C, or Z (C or Z only
          if complex).
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2015

Definition at line 95 of file alahd.f.

95 *
96 * -- LAPACK test routine (version 3.6.0) --
97 * -- LAPACK is a software package provided by Univ. of Tennessee, --
98 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
99 * November 2015
100 *
101 * .. Scalar Arguments ..
102  CHARACTER*3 path
103  INTEGER iounit
104 * ..
105 *
106 * =====================================================================
107 *
108 * .. Local Scalars ..
109  LOGICAL corz, sord
110  CHARACTER c1, c3
111  CHARACTER*2 p2
112  CHARACTER*4 eigcnm
113  CHARACTER*32 subnam
114  CHARACTER*9 sym
115 * ..
116 * .. External Functions ..
117  LOGICAL lsame, lsamen
118  EXTERNAL lsame, lsamen
119 * ..
120 * .. Intrinsic Functions ..
121  INTRINSIC len_trim
122 * ..
123 * .. Executable Statements ..
124 *
125  IF( iounit.LE.0 )
126  $ RETURN
127  c1 = path( 1: 1 )
128  c3 = path( 3: 3 )
129  p2 = path( 2: 3 )
130  sord = lsame( c1, 'S' ) .OR. lsame( c1, 'D' )
131  corz = lsame( c1, 'C' ) .OR. lsame( c1, 'Z' )
132  IF( .NOT.( sord .OR. corz ) )
133  $ RETURN
134 *
135  IF( lsamen( 2, p2, 'GE' ) ) THEN
136 *
137 * GE: General dense
138 *
139  WRITE( iounit, fmt = 9999 )path
140  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
141  WRITE( iounit, fmt = 9979 )
142  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
143  WRITE( iounit, fmt = 9962 )1
144  WRITE( iounit, fmt = 9961 )2
145  WRITE( iounit, fmt = 9960 )3
146  WRITE( iounit, fmt = 9959 )4
147  WRITE( iounit, fmt = 9958 )5
148  WRITE( iounit, fmt = 9957 )6
149  WRITE( iounit, fmt = 9956 )7
150  WRITE( iounit, fmt = 9955 )8
151  WRITE( iounit, fmt = '( '' Messages:'' )' )
152 *
153  ELSE IF( lsamen( 2, p2, 'GB' ) ) THEN
154 *
155 * GB: General band
156 *
157  WRITE( iounit, fmt = 9998 )path
158  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
159  WRITE( iounit, fmt = 9978 )
160  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
161  WRITE( iounit, fmt = 9962 )1
162  WRITE( iounit, fmt = 9960 )2
163  WRITE( iounit, fmt = 9959 )3
164  WRITE( iounit, fmt = 9958 )4
165  WRITE( iounit, fmt = 9957 )5
166  WRITE( iounit, fmt = 9956 )6
167  WRITE( iounit, fmt = 9955 )7
168  WRITE( iounit, fmt = '( '' Messages:'' )' )
169 *
170  ELSE IF( lsamen( 2, p2, 'GT' ) ) THEN
171 *
172 * GT: General tridiagonal
173 *
174  WRITE( iounit, fmt = 9997 )path
175  WRITE( iounit, fmt = 9977 )
176  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
177  WRITE( iounit, fmt = 9962 )1
178  WRITE( iounit, fmt = 9960 )2
179  WRITE( iounit, fmt = 9959 )3
180  WRITE( iounit, fmt = 9958 )4
181  WRITE( iounit, fmt = 9957 )5
182  WRITE( iounit, fmt = 9956 )6
183  WRITE( iounit, fmt = 9955 )7
184  WRITE( iounit, fmt = '( '' Messages:'' )' )
185 *
186  ELSE IF( lsamen( 2, p2, 'PO' ) .OR. lsamen( 2, p2, 'PP' ) ) THEN
187 *
188 * PO: Positive definite full
189 * PP: Positive definite packed
190 *
191  IF( sord ) THEN
192  sym = 'Symmetric'
193  ELSE
194  sym = 'Hermitian'
195  END IF
196  IF( lsame( c3, 'O' ) ) THEN
197  WRITE( iounit, fmt = 9996 )path, sym
198  ELSE
199  WRITE( iounit, fmt = 9995 )path, sym
200  END IF
201  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
202  WRITE( iounit, fmt = 9975 )path
203  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
204  WRITE( iounit, fmt = 9954 )1
205  WRITE( iounit, fmt = 9961 )2
206  WRITE( iounit, fmt = 9960 )3
207  WRITE( iounit, fmt = 9959 )4
208  WRITE( iounit, fmt = 9958 )5
209  WRITE( iounit, fmt = 9957 )6
210  WRITE( iounit, fmt = 9956 )7
211  WRITE( iounit, fmt = 9955 )8
212  WRITE( iounit, fmt = '( '' Messages:'' )' )
213 *
214  ELSE IF( lsamen( 2, p2, 'PS' ) ) THEN
215 *
216 * PS: Positive semi-definite full
217 *
218  IF( sord ) THEN
219  sym = 'Symmetric'
220  ELSE
221  sym = 'Hermitian'
222  END IF
223  IF( lsame( c1, 'S' ) .OR. lsame( c1, 'C' ) ) THEN
224  eigcnm = '1E04'
225  ELSE
226  eigcnm = '1D12'
227  END IF
228  WRITE( iounit, fmt = 9995 )path, sym
229  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
230  WRITE( iounit, fmt = 8973 )eigcnm, eigcnm, eigcnm
231  WRITE( iounit, fmt = '( '' Difference:'' )' )
232  WRITE( iounit, fmt = 8972 )c1
233  WRITE( iounit, fmt = '( '' Test ratio:'' )' )
234  WRITE( iounit, fmt = 8950 )
235  WRITE( iounit, fmt = '( '' Messages:'' )' )
236  ELSE IF( lsamen( 2, p2, 'PB' ) ) THEN
237 *
238 * PB: Positive definite band
239 *
240  IF( sord ) THEN
241  WRITE( iounit, fmt = 9994 )path, 'Symmetric'
242  ELSE
243  WRITE( iounit, fmt = 9994 )path, 'Hermitian'
244  END IF
245  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
246  WRITE( iounit, fmt = 9973 )path
247  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
248  WRITE( iounit, fmt = 9954 )1
249  WRITE( iounit, fmt = 9960 )2
250  WRITE( iounit, fmt = 9959 )3
251  WRITE( iounit, fmt = 9958 )4
252  WRITE( iounit, fmt = 9957 )5
253  WRITE( iounit, fmt = 9956 )6
254  WRITE( iounit, fmt = 9955 )7
255  WRITE( iounit, fmt = '( '' Messages:'' )' )
256 *
257  ELSE IF( lsamen( 2, p2, 'PT' ) ) THEN
258 *
259 * PT: Positive definite tridiagonal
260 *
261  IF( sord ) THEN
262  WRITE( iounit, fmt = 9993 )path, 'Symmetric'
263  ELSE
264  WRITE( iounit, fmt = 9993 )path, 'Hermitian'
265  END IF
266  WRITE( iounit, fmt = 9976 )
267  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
268  WRITE( iounit, fmt = 9952 )1
269  WRITE( iounit, fmt = 9960 )2
270  WRITE( iounit, fmt = 9959 )3
271  WRITE( iounit, fmt = 9958 )4
272  WRITE( iounit, fmt = 9957 )5
273  WRITE( iounit, fmt = 9956 )6
274  WRITE( iounit, fmt = 9955 )7
275  WRITE( iounit, fmt = '( '' Messages:'' )' )
276 *
277  ELSE IF( lsamen( 2, p2, 'SY' ) ) THEN
278 *
279 * SY: Symmetric indefinite full,
280 * with partial (Bunch-Kaufman) pivoting algorithm
281 *
282  IF( lsame( c3, 'Y' ) ) THEN
283  WRITE( iounit, fmt = 9992 )path, 'Symmetric'
284  ELSE
285  WRITE( iounit, fmt = 9991 )path, 'Symmetric'
286  END IF
287  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
288  IF( sord ) THEN
289  WRITE( iounit, fmt = 9972 )
290  ELSE
291  WRITE( iounit, fmt = 9971 )
292  END IF
293  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
294  WRITE( iounit, fmt = 9953 )1
295  WRITE( iounit, fmt = 9961 )2
296  WRITE( iounit, fmt = 9960 )3
297  WRITE( iounit, fmt = 9960 )4
298  WRITE( iounit, fmt = 9959 )5
299  WRITE( iounit, fmt = 9958 )6
300  WRITE( iounit, fmt = 9956 )7
301  WRITE( iounit, fmt = 9957 )8
302  WRITE( iounit, fmt = 9955 )9
303  WRITE( iounit, fmt = '( '' Messages:'' )' )
304 *
305  ELSE IF( lsamen( 2, p2, 'SR' ) ) THEN
306 *
307 * SR: Symmetric indefinite full,
308 * with "rook" (bounded Bunch-Kaufman) pivoting algorithm
309 *
310  WRITE( iounit, fmt = 9892 )path, 'Symmetric'
311 *
312  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
313  IF( sord ) THEN
314  WRITE( iounit, fmt = 9972 )
315  ELSE
316  WRITE( iounit, fmt = 9971 )
317  END IF
318 *
319  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
320  WRITE( iounit, fmt = 9953 )1
321  WRITE( iounit, fmt = 9961 )2
322  WRITE( iounit, fmt = 9927 )3
323  WRITE( iounit, fmt = 9928 )
324  WRITE( iounit, fmt = 9926 )4
325  WRITE( iounit, fmt = 9928 )
326  WRITE( iounit, fmt = 9960 )5
327  WRITE( iounit, fmt = 9959 )6
328  WRITE( iounit, fmt = 9955 )7
329  WRITE( iounit, fmt = '( '' Messages:'' )' )
330 *
331  ELSE IF( lsamen( 2, p2, 'SP' ) ) THEN
332 *
333 * SP: Symmetric indefinite packed,
334 * with partial (Bunch-Kaufman) pivoting algorithm
335 *
336  IF( lsame( c3, 'Y' ) ) THEN
337  WRITE( iounit, fmt = 9992 )path, 'Symmetric'
338  ELSE
339  WRITE( iounit, fmt = 9991 )path, 'Symmetric'
340  END IF
341  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
342  IF( sord ) THEN
343  WRITE( iounit, fmt = 9972 )
344  ELSE
345  WRITE( iounit, fmt = 9971 )
346  END IF
347  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
348  WRITE( iounit, fmt = 9953 )1
349  WRITE( iounit, fmt = 9961 )2
350  WRITE( iounit, fmt = 9960 )3
351  WRITE( iounit, fmt = 9959 )4
352  WRITE( iounit, fmt = 9958 )5
353  WRITE( iounit, fmt = 9956 )6
354  WRITE( iounit, fmt = 9957 )7
355  WRITE( iounit, fmt = 9955 )8
356  WRITE( iounit, fmt = '( '' Messages:'' )' )
357 *
358  ELSE IF( lsamen( 2, p2, 'HE' ) ) THEN
359 *
360 * HE: Hermitian indefinite full,
361 * with partial (Bunch-Kaufman) pivoting algorithm
362 *
363  WRITE( iounit, fmt = 9992 )path, 'Hermitian'
364 *
365  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
366  WRITE( iounit, fmt = 9972 )
367 *
368  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
369  WRITE( iounit, fmt = 9953 )1
370  WRITE( iounit, fmt = 9961 )2
371  WRITE( iounit, fmt = 9960 )3
372  WRITE( iounit, fmt = 9960 )4
373  WRITE( iounit, fmt = 9959 )5
374  WRITE( iounit, fmt = 9958 )6
375  WRITE( iounit, fmt = 9956 )7
376  WRITE( iounit, fmt = 9957 )8
377  WRITE( iounit, fmt = 9955 )9
378  WRITE( iounit, fmt = '( '' Messages:'' )' )
379 *
380  ELSE IF( lsamen( 2, p2, 'HR' ) ) THEN
381 *
382 * HR: Symmetric indefinite full,
383 * with "rook" (bounded Bunch-Kaufman) pivoting algorithm
384 *
385  WRITE( iounit, fmt = 9892 )path, 'Hermitian'
386 *
387  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
388  WRITE( iounit, fmt = 9972 )
389 *
390  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
391  WRITE( iounit, fmt = 9953 )1
392  WRITE( iounit, fmt = 9961 )2
393  WRITE( iounit, fmt = 9927 )3
394  WRITE( iounit, fmt = 9928 )
395  WRITE( iounit, fmt = 9926 )4
396  WRITE( iounit, fmt = 9928 )
397  WRITE( iounit, fmt = 9960 )5
398  WRITE( iounit, fmt = 9959 )6
399  WRITE( iounit, fmt = 9955 )7
400  WRITE( iounit, fmt = '( '' Messages:'' )' )
401 *
402  ELSE IF( lsamen( 2, p2, 'HP' ) ) THEN
403 *
404 * HP: Hermitian indefinite packed,
405 * with partial (Bunch-Kaufman) pivoting algorithm
406 *
407  IF( lsame( c3, 'E' ) ) THEN
408  WRITE( iounit, fmt = 9992 )path, 'Hermitian'
409  ELSE
410  WRITE( iounit, fmt = 9991 )path, 'Hermitian'
411  END IF
412  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
413  WRITE( iounit, fmt = 9972 )
414  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
415  WRITE( iounit, fmt = 9953 )1
416  WRITE( iounit, fmt = 9961 )2
417  WRITE( iounit, fmt = 9960 )3
418  WRITE( iounit, fmt = 9959 )4
419  WRITE( iounit, fmt = 9958 )5
420  WRITE( iounit, fmt = 9956 )6
421  WRITE( iounit, fmt = 9957 )7
422  WRITE( iounit, fmt = 9955 )8
423  WRITE( iounit, fmt = '( '' Messages:'' )' )
424 *
425  ELSE IF( lsamen( 2, p2, 'TR' ) .OR. lsamen( 2, p2, 'TP' ) ) THEN
426 *
427 * TR: Triangular full
428 * TP: Triangular packed
429 *
430  IF( lsame( c3, 'R' ) ) THEN
431  WRITE( iounit, fmt = 9990 )path
432  subnam = path( 1: 1 ) // 'LATRS'
433  ELSE
434  WRITE( iounit, fmt = 9989 )path
435  subnam = path( 1: 1 ) // 'LATPS'
436  END IF
437  WRITE( iounit, fmt = 9966 )path
438  WRITE( iounit, fmt = 9965 )subnam(1:len_trim( subnam ))
439  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
440  WRITE( iounit, fmt = 9961 )1
441  WRITE( iounit, fmt = 9960 )2
442  WRITE( iounit, fmt = 9959 )3
443  WRITE( iounit, fmt = 9958 )4
444  WRITE( iounit, fmt = 9957 )5
445  WRITE( iounit, fmt = 9956 )6
446  WRITE( iounit, fmt = 9955 )7
447  WRITE( iounit, fmt = 9951 )subnam(1:len_trim( subnam )), 8
448  WRITE( iounit, fmt = '( '' Messages:'' )' )
449 *
450  ELSE IF( lsamen( 2, p2, 'TB' ) ) THEN
451 *
452 * TB: Triangular band
453 *
454  WRITE( iounit, fmt = 9988 )path
455  subnam = path( 1: 1 ) // 'LATBS'
456  WRITE( iounit, fmt = 9964 )path
457  WRITE( iounit, fmt = 9963 )subnam(1:len_trim( subnam ))
458  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
459  WRITE( iounit, fmt = 9960 )1
460  WRITE( iounit, fmt = 9959 )2
461  WRITE( iounit, fmt = 9958 )3
462  WRITE( iounit, fmt = 9957 )4
463  WRITE( iounit, fmt = 9956 )5
464  WRITE( iounit, fmt = 9955 )6
465  WRITE( iounit, fmt = 9951 )subnam(1:len_trim( subnam )), 7
466  WRITE( iounit, fmt = '( '' Messages:'' )' )
467 *
468  ELSE IF( lsamen( 2, p2, 'QR' ) ) THEN
469 *
470 * QR decomposition of rectangular matrices
471 *
472  WRITE( iounit, fmt = 9987 )path, 'QR'
473  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
474  WRITE( iounit, fmt = 9970 )
475  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
476  WRITE( iounit, fmt = 9950 )1
477  WRITE( iounit, fmt = 6950 )8
478  WRITE( iounit, fmt = 9946 )2
479  WRITE( iounit, fmt = 9944 )3, 'M'
480  WRITE( iounit, fmt = 9943 )4, 'M'
481  WRITE( iounit, fmt = 9942 )5, 'M'
482  WRITE( iounit, fmt = 9941 )6, 'M'
483  WRITE( iounit, fmt = 9960 )7
484  WRITE( iounit, fmt = 6660 )9
485  WRITE( iounit, fmt = '( '' Messages:'' )' )
486 *
487  ELSE IF( lsamen( 2, p2, 'LQ' ) ) THEN
488 *
489 * LQ decomposition of rectangular matrices
490 *
491  WRITE( iounit, fmt = 9987 )path, 'LQ'
492  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
493  WRITE( iounit, fmt = 9970 )
494  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
495  WRITE( iounit, fmt = 9949 )1
496  WRITE( iounit, fmt = 9945 )2
497  WRITE( iounit, fmt = 9944 )3, 'N'
498  WRITE( iounit, fmt = 9943 )4, 'N'
499  WRITE( iounit, fmt = 9942 )5, 'N'
500  WRITE( iounit, fmt = 9941 )6, 'N'
501  WRITE( iounit, fmt = 9960 )7
502  WRITE( iounit, fmt = '( '' Messages:'' )' )
503 *
504  ELSE IF( lsamen( 2, p2, 'QL' ) ) THEN
505 *
506 * QL decomposition of rectangular matrices
507 *
508  WRITE( iounit, fmt = 9987 )path, 'QL'
509  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
510  WRITE( iounit, fmt = 9970 )
511  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
512  WRITE( iounit, fmt = 9948 )1
513  WRITE( iounit, fmt = 9946 )2
514  WRITE( iounit, fmt = 9944 )3, 'M'
515  WRITE( iounit, fmt = 9943 )4, 'M'
516  WRITE( iounit, fmt = 9942 )5, 'M'
517  WRITE( iounit, fmt = 9941 )6, 'M'
518  WRITE( iounit, fmt = 9960 )7
519  WRITE( iounit, fmt = '( '' Messages:'' )' )
520 *
521  ELSE IF( lsamen( 2, p2, 'RQ' ) ) THEN
522 *
523 * RQ decomposition of rectangular matrices
524 *
525  WRITE( iounit, fmt = 9987 )path, 'RQ'
526  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
527  WRITE( iounit, fmt = 9970 )
528  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
529  WRITE( iounit, fmt = 9947 )1
530  WRITE( iounit, fmt = 9945 )2
531  WRITE( iounit, fmt = 9944 )3, 'N'
532  WRITE( iounit, fmt = 9943 )4, 'N'
533  WRITE( iounit, fmt = 9942 )5, 'N'
534  WRITE( iounit, fmt = 9941 )6, 'N'
535  WRITE( iounit, fmt = 9960 )7
536  WRITE( iounit, fmt = '( '' Messages:'' )' )
537 *
538  ELSE IF( lsamen( 2, p2, 'QP' ) ) THEN
539 *
540 * QR decomposition with column pivoting
541 *
542  WRITE( iounit, fmt = 9986 )path
543  WRITE( iounit, fmt = 9969 )
544  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
545  WRITE( iounit, fmt = 9940 )1
546  WRITE( iounit, fmt = 9939 )2
547  WRITE( iounit, fmt = 9938 )3
548  WRITE( iounit, fmt = '( '' Messages:'' )' )
549 *
550  ELSE IF( lsamen( 2, p2, 'TZ' ) ) THEN
551 *
552 * TZ: Trapezoidal
553 *
554  WRITE( iounit, fmt = 9985 )path
555  WRITE( iounit, fmt = 9968 )
556  WRITE( iounit, fmt = 9929 )c1
557  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
558  WRITE( iounit, fmt = 9940 )1
559  WRITE( iounit, fmt = 9937 )2
560  WRITE( iounit, fmt = 9938 )3
561  WRITE( iounit, fmt = '( '' Messages:'' )' )
562 *
563  ELSE IF( lsamen( 2, p2, 'LS' ) ) THEN
564 *
565 * LS: Least Squares driver routines for
566 * LS, LSD, LSS, LSX and LSY.
567 *
568  WRITE( iounit, fmt = 9984 )path
569  WRITE( iounit, fmt = 9967 )
570  WRITE( iounit, fmt = 9921 )c1, c1, c1, c1
571  WRITE( iounit, fmt = 9935 )1
572  WRITE( iounit, fmt = 9931 )2
573  WRITE( iounit, fmt = 9933 )3
574  WRITE( iounit, fmt = 9935 )4
575  WRITE( iounit, fmt = 9934 )5
576  WRITE( iounit, fmt = 9932 )6
577  WRITE( iounit, fmt = 9920 )
578  WRITE( iounit, fmt = '( '' Messages:'' )' )
579 *
580  ELSE IF( lsamen( 2, p2, 'LU' ) ) THEN
581 *
582 * LU factorization variants
583 *
584  WRITE( iounit, fmt = 9983 )path
585  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
586  WRITE( iounit, fmt = 9979 )
587  WRITE( iounit, fmt = '( '' Test ratio:'' )' )
588  WRITE( iounit, fmt = 9962 )1
589  WRITE( iounit, fmt = '( '' Messages:'' )' )
590 *
591  ELSE IF( lsamen( 2, p2, 'CH' ) ) THEN
592 *
593 * Cholesky factorization variants
594 *
595  WRITE( iounit, fmt = 9982 )path
596  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
597  WRITE( iounit, fmt = 9974 )
598  WRITE( iounit, fmt = '( '' Test ratio:'' )' )
599  WRITE( iounit, fmt = 9954 )1
600  WRITE( iounit, fmt = '( '' Messages:'' )' )
601 *
602  ELSE IF( lsamen( 2, p2, 'QS' ) ) THEN
603 *
604 * QR factorization variants
605 *
606  WRITE( iounit, fmt = 9981 )path
607  WRITE( iounit, fmt = '( '' Matrix types:'' )' )
608  WRITE( iounit, fmt = 9970 )
609  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
610 *
611  ELSE IF( lsamen( 2, p2, 'QT' ) ) THEN
612 *
613 * QRT (general matrices)
614 *
615  WRITE( iounit, fmt = 8000 ) path
616  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
617  WRITE( iounit, fmt = 8011 ) 1
618  WRITE( iounit, fmt = 8012 ) 2
619  WRITE( iounit, fmt = 8013 ) 3
620  WRITE( iounit, fmt = 8014 ) 4
621  WRITE( iounit, fmt = 8015 ) 5
622  WRITE( iounit, fmt = 8016 ) 6
623 *
624  ELSE IF( lsamen( 2, p2, 'QX' ) ) THEN
625 *
626 * QRT (triangular-pentagonal)
627 *
628  WRITE( iounit, fmt = 8001 ) path
629  WRITE( iounit, fmt = '( '' Test ratios:'' )' )
630  WRITE( iounit, fmt = 8017 ) 1
631  WRITE( iounit, fmt = 8018 ) 2
632  WRITE( iounit, fmt = 8019 ) 3
633  WRITE( iounit, fmt = 8020 ) 4
634  WRITE( iounit, fmt = 8021 ) 5
635  WRITE( iounit, fmt = 8022 ) 6
636 *
637  ELSE
638 *
639 * Print error message if no header is available.
640 *
641  WRITE( iounit, fmt = 9980 )path
642  END IF
643 *
644 * First line of header
645 *
646  9999 FORMAT( / 1x, a3, ': General dense matrices' )
647  9998 FORMAT( / 1x, a3, ': General band matrices' )
648  9997 FORMAT( / 1x, a3, ': General tridiagonal' )
649  9996 FORMAT( / 1x, a3, ': ', a9, ' positive definite matrices' )
650  9995 FORMAT( / 1x, a3, ': ', a9, ' positive definite packed matrices'
651  $ )
652  9994 FORMAT( / 1x, a3, ': ', a9, ' positive definite band matrices' )
653  9993 FORMAT( / 1x, a3, ': ', a9, ' positive definite tridiagonal' )
654  9992 FORMAT( / 1x, a3, ': ', a9, ' indefinite matrices',
655  $ ', partial (Bunch-Kaufman) pivoting' )
656  9991 FORMAT( / 1x, a3, ': ', a9, ' indefinite packed matrices',
657  $ ', partial (Bunch-Kaufman) pivoting' )
658  9892 FORMAT( / 1x, a3, ': ', a9, ' indefinite matrices',
659  $ ', "rook" (bounded Bunch-Kaufman) pivoting' )
660  9891 FORMAT( / 1x, a3, ': ', a9, ' indefinite packed matrices',
661  $ ', "rook" (bounded Bunch-Kaufman) pivoting' )
662  9990 FORMAT( / 1x, a3, ': Triangular matrices' )
663  9989 FORMAT( / 1x, a3, ': Triangular packed matrices' )
664  9988 FORMAT( / 1x, a3, ': Triangular band matrices' )
665  9987 FORMAT( / 1x, a3, ': ', a2, ' factorization of general matrices'
666  $ )
667  9986 FORMAT( / 1x, a3, ': QR factorization with column pivoting' )
668  9985 FORMAT( / 1x, a3, ': RQ factorization of trapezoidal matrix' )
669  9984 FORMAT( / 1x, a3, ': Least squares driver routines' )
670  9983 FORMAT( / 1x, a3, ': LU factorization variants' )
671  9982 FORMAT( / 1x, a3, ': Cholesky factorization variants' )
672  9981 FORMAT( / 1x, a3, ': QR factorization variants' )
673  9980 FORMAT( / 1x, a3, ': No header available' )
674  8000 FORMAT( / 1x, a3, ': QRT factorization for general matrices' )
675  8001 FORMAT( / 1x, a3, ': QRT factorization for ',
676  $ 'triangular-pentagonal matrices' )
677 *
678 * GE matrix types
679 *
680  9979 FORMAT( 4x, '1. Diagonal', 24x, '7. Last n/2 columns zero', / 4x,
681  $ '2. Upper triangular', 16x,
682  $ '8. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
683  $ '3. Lower triangular', 16x, '9. Random, CNDNUM = 0.1/EPS',
684  $ / 4x, '4. Random, CNDNUM = 2', 13x,
685  $ '10. Scaled near underflow', / 4x, '5. First column zero',
686  $ 14x, '11. Scaled near overflow', / 4x,
687  $ '6. Last column zero' )
688 *
689 * GB matrix types
690 *
691  9978 FORMAT( 4x, '1. Random, CNDNUM = 2', 14x,
692  $ '5. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
693  $ '2. First column zero', 15x, '6. Random, CNDNUM = .01/EPS',
694  $ / 4x, '3. Last column zero', 16x,
695  $ '7. Scaled near underflow', / 4x,
696  $ '4. Last n/2 columns zero', 11x, '8. Scaled near overflow' )
697 *
698 * GT matrix types
699 *
700  9977 FORMAT( ' Matrix types (1-6 have specified condition numbers):',
701  $ / 4x, '1. Diagonal', 24x, '7. Random, unspecified CNDNUM',
702  $ / 4x, '2. Random, CNDNUM = 2', 14x, '8. First column zero',
703  $ / 4x, '3. Random, CNDNUM = sqrt(0.1/EPS)', 2x,
704  $ '9. Last column zero', / 4x, '4. Random, CNDNUM = 0.1/EPS',
705  $ 7x, '10. Last n/2 columns zero', / 4x,
706  $ '5. Scaled near underflow', 10x,
707  $ '11. Scaled near underflow', / 4x,
708  $ '6. Scaled near overflow', 11x, '12. Scaled near overflow' )
709 *
710 * PT matrix types
711 *
712  9976 FORMAT( ' Matrix types (1-6 have specified condition numbers):',
713  $ / 4x, '1. Diagonal', 24x, '7. Random, unspecified CNDNUM',
714  $ / 4x, '2. Random, CNDNUM = 2', 14x,
715  $ '8. First row and column zero', / 4x,
716  $ '3. Random, CNDNUM = sqrt(0.1/EPS)', 2x,
717  $ '9. Last row and column zero', / 4x,
718  $ '4. Random, CNDNUM = 0.1/EPS', 7x,
719  $ '10. Middle row and column zero', / 4x,
720  $ '5. Scaled near underflow', 10x,
721  $ '11. Scaled near underflow', / 4x,
722  $ '6. Scaled near overflow', 11x, '12. Scaled near overflow' )
723 *
724 * PO, PP matrix types
725 *
726  9975 FORMAT( 4x, '1. Diagonal', 24x,
727  $ '6. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
728  $ '2. Random, CNDNUM = 2', 14x, '7. Random, CNDNUM = 0.1/EPS',
729  $ / 3x, '*3. First row and column zero', 7x,
730  $ '8. Scaled near underflow', / 3x,
731  $ '*4. Last row and column zero', 8x,
732  $ '9. Scaled near overflow', / 3x,
733  $ '*5. Middle row and column zero', / 3x,
734  $ '(* - tests error exits from ', a3,
735  $ 'TRF, no test ratios are computed)' )
736 *
737 * CH matrix types
738 *
739  9974 FORMAT( 4x, '1. Diagonal', 24x,
740  $ '6. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
741  $ '2. Random, CNDNUM = 2', 14x, '7. Random, CNDNUM = 0.1/EPS',
742  $ / 3x, '*3. First row and column zero', 7x,
743  $ '8. Scaled near underflow', / 3x,
744  $ '*4. Last row and column zero', 8x,
745  $ '9. Scaled near overflow', / 3x,
746  $ '*5. Middle row and column zero', / 3x,
747  $ '(* - tests error exits, no test ratios are computed)' )
748 *
749 * PS matrix types
750 *
751  8973 FORMAT( 4x, '1. Diagonal', / 4x, '2. Random, CNDNUM = 2', 14x,
752  $ / 3x, '*3. Nonzero eigenvalues of: D(1:RANK-1)=1 and ',
753  $ 'D(RANK) = 1.0/', a4, / 3x,
754  $ '*4. Nonzero eigenvalues of: D(1)=1 and ',
755  $ ' D(2:RANK) = 1.0/', a4, / 3x,
756  $ '*5. Nonzero eigenvalues of: D(I) = ', a4,
757  $ '**(-(I-1)/(RANK-1)) ', ' I=1:RANK', / 4x,
758  $ '6. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
759  $ '7. Random, CNDNUM = 0.1/EPS', / 4x,
760  $ '8. Scaled near underflow', / 4x, '9. Scaled near overflow',
761  $ / 3x, '(* - Semi-definite tests )' )
762  8972 FORMAT( 3x, 'RANK minus computed rank, returned by ', a, 'PSTRF' )
763 *
764 * PB matrix types
765 *
766  9973 FORMAT( 4x, '1. Random, CNDNUM = 2', 14x,
767  $ '5. Random, CNDNUM = sqrt(0.1/EPS)', / 3x,
768  $ '*2. First row and column zero', 7x,
769  $ '6. Random, CNDNUM = 0.1/EPS', / 3x,
770  $ '*3. Last row and column zero', 8x,
771  $ '7. Scaled near underflow', / 3x,
772  $ '*4. Middle row and column zero', 6x,
773  $ '8. Scaled near overflow', / 3x,
774  $ '(* - tests error exits from ', a3,
775  $ 'TRF, no test ratios are computed)' )
776 *
777 * SSY, SSR, SSP, CHE, CHR, CHP matrix types
778 *
779  9972 FORMAT( 4x, '1. Diagonal', 24x,
780  $ '6. Last n/2 rows and columns zero', / 4x,
781  $ '2. Random, CNDNUM = 2', 14x,
782  $ '7. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
783  $ '3. First row and column zero', 7x,
784  $ '8. Random, CNDNUM = 0.1/EPS', / 4x,
785  $ '4. Last row and column zero', 8x,
786  $ '9. Scaled near underflow', / 4x,
787  $ '5. Middle row and column zero', 5x,
788  $ '10. Scaled near overflow' )
789 *
790 * CSY, CSR, CSP matrix types
791 *
792  9971 FORMAT( 4x, '1. Diagonal', 24x,
793  $ '7. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
794  $ '2. Random, CNDNUM = 2', 14x, '8. Random, CNDNUM = 0.1/EPS',
795  $ / 4x, '3. First row and column zero', 7x,
796  $ '9. Scaled near underflow', / 4x,
797  $ '4. Last row and column zero', 7x,
798  $ '10. Scaled near overflow', / 4x,
799  $ '5. Middle row and column zero', 5x,
800  $ '11. Block diagonal matrix', / 4x,
801  $ '6. Last n/2 rows and columns zero' )
802 *
803 * QR matrix types
804 *
805  9970 FORMAT( 4x, '1. Diagonal', 24x,
806  $ '5. Random, CNDNUM = sqrt(0.1/EPS)', / 4x,
807  $ '2. Upper triangular', 16x, '6. Random, CNDNUM = 0.1/EPS',
808  $ / 4x, '3. Lower triangular', 16x,
809  $ '7. Scaled near underflow', / 4x, '4. Random, CNDNUM = 2',
810  $ 14x, '8. Scaled near overflow' )
811 *
812 * QP matrix types
813 *
814  9969 FORMAT( ' Matrix types (2-6 have condition 1/EPS):', / 4x,
815  $ '1. Zero matrix', 21x, '4. First n/2 columns fixed', / 4x,
816  $ '2. One small eigenvalue', 12x, '5. Last n/2 columns fixed',
817  $ / 4x, '3. Geometric distribution', 10x,
818  $ '6. Every second column fixed' )
819 *
820 * TZ matrix types
821 *
822  9968 FORMAT( ' Matrix types (2-3 have condition 1/EPS):', / 4x,
823  $ '1. Zero matrix', / 4x, '2. One small eigenvalue', / 4x,
824  $ '3. Geometric distribution' )
825 *
826 * LS matrix types
827 *
828  9967 FORMAT( ' Matrix types (1-3: full rank, 4-6: rank deficient):',
829  $ / 4x, '1 and 4. Normal scaling', / 4x,
830  $ '2 and 5. Scaled near overflow', / 4x,
831  $ '3 and 6. Scaled near underflow' )
832 *
833 * TR, TP matrix types
834 *
835  9966 FORMAT( ' Matrix types for ', a3, ' routines:', / 4x,
836  $ '1. Diagonal', 24x, '6. Scaled near overflow', / 4x,
837  $ '2. Random, CNDNUM = 2', 14x, '7. Identity', / 4x,
838  $ '3. Random, CNDNUM = sqrt(0.1/EPS) ',
839  $ '8. Unit triangular, CNDNUM = 2', / 4x,
840  $ '4. Random, CNDNUM = 0.1/EPS', 8x,
841  $ '9. Unit, CNDNUM = sqrt(0.1/EPS)', / 4x,
842  $ '5. Scaled near underflow', 10x,
843  $ '10. Unit, CNDNUM = 0.1/EPS' )
844  9965 FORMAT( ' Special types for testing ', a, ':', / 3x,
845  $ '11. Matrix elements are O(1), large right hand side', / 3x,
846  $ '12. First diagonal causes overflow,',
847  $ ' offdiagonal column norms < 1', / 3x,
848  $ '13. First diagonal causes overflow,',
849  $ ' offdiagonal column norms > 1', / 3x,
850  $ '14. Growth factor underflows, solution does not overflow',
851  $ / 3x, '15. Small diagonal causes gradual overflow', / 3x,
852  $ '16. One zero diagonal element', / 3x,
853  $ '17. Large offdiagonals cause overflow when adding a column'
854  $ , / 3x, '18. Unit triangular with large right hand side' )
855 *
856 * TB matrix types
857 *
858  9964 FORMAT( ' Matrix types for ', a3, ' routines:', / 4x,
859  $ '1. Random, CNDNUM = 2', 14x, '6. Identity', / 4x,
860  $ '2. Random, CNDNUM = sqrt(0.1/EPS) ',
861  $ '7. Unit triangular, CNDNUM = 2', / 4x,
862  $ '3. Random, CNDNUM = 0.1/EPS', 8x,
863  $ '8. Unit, CNDNUM = sqrt(0.1/EPS)', / 4x,
864  $ '4. Scaled near underflow', 11x,
865  $ '9. Unit, CNDNUM = 0.1/EPS', / 4x,
866  $ '5. Scaled near overflow' )
867  9963 FORMAT( ' Special types for testing ', a, ':', / 3x,
868  $ '10. Matrix elements are O(1), large right hand side', / 3x,
869  $ '11. First diagonal causes overflow,',
870  $ ' offdiagonal column norms < 1', / 3x,
871  $ '12. First diagonal causes overflow,',
872  $ ' offdiagonal column norms > 1', / 3x,
873  $ '13. Growth factor underflows, solution does not overflow',
874  $ / 3x, '14. Small diagonal causes gradual overflow', / 3x,
875  $ '15. One zero diagonal element', / 3x,
876  $ '16. Large offdiagonals cause overflow when adding a column'
877  $ , / 3x, '17. Unit triangular with large right hand side' )
878 *
879 * Test ratios
880 *
881  9962 FORMAT( 3x, i2, ': norm( L * U - A ) / ( N * norm(A) * EPS )' )
882  9961 FORMAT( 3x, i2, ': norm( I - A*AINV ) / ',
883  $ '( N * norm(A) * norm(AINV) * EPS )' )
884  9960 FORMAT( 3x, i2, ': norm( B - A * X ) / ',
885  $ '( norm(A) * norm(X) * EPS )' )
886  6660 FORMAT( 3x, i2, ': diagonal is not non-negative')
887  9959 FORMAT( 3x, i2, ': norm( X - XACT ) / ',
888  $ '( norm(XACT) * CNDNUM * EPS )' )
889  9958 FORMAT( 3x, i2, ': norm( X - XACT ) / ',
890  $ '( norm(XACT) * CNDNUM * EPS ), refined' )
891  9957 FORMAT( 3x, i2, ': norm( X - XACT ) / ',
892  $ '( norm(XACT) * (error bound) )' )
893  9956 FORMAT( 3x, i2, ': (backward error) / EPS' )
894  9955 FORMAT( 3x, i2, ': RCOND * CNDNUM - 1.0' )
895  9954 FORMAT( 3x, i2, ': norm( U'' * U - A ) / ( N * norm(A) * EPS )',
896  $ ', or', / 7x, 'norm( L * L'' - A ) / ( N * norm(A) * EPS )'
897  $ )
898  8950 FORMAT( 3x,
899  $ 'norm( P * U'' * U * P'' - A ) / ( N * norm(A) * EPS )',
900  $ ', or', / 3x,
901  $ 'norm( P * L * L'' * P'' - A ) / ( N * norm(A) * EPS )' )
902  9953 FORMAT( 3x, i2, ': norm( U*D*U'' - A ) / ( N * norm(A) * EPS )',
903  $ ', or', / 7x, 'norm( L*D*L'' - A ) / ( N * norm(A) * EPS )'
904  $ )
905  9952 FORMAT( 3x, i2, ': norm( U''*D*U - A ) / ( N * norm(A) * EPS )',
906  $ ', or', / 7x, 'norm( L*D*L'' - A ) / ( N * norm(A) * EPS )'
907  $ )
908  9951 FORMAT( ' Test ratio for ', a, ':', / 3x, i2,
909  $ ': norm( s*b - A*x ) / ( norm(A) * norm(x) * EPS )' )
910  9950 FORMAT( 3x, i2, ': norm( R - Q'' * A ) / ( M * norm(A) * EPS )' )
911  6950 FORMAT( 3x, i2, ': norm( R - Q'' * A ) / ( M * norm(A) * EPS )
912  $ [RFPG]' )
913  9949 FORMAT( 3x, i2, ': norm( L - A * Q'' ) / ( N * norm(A) * EPS )' )
914  9948 FORMAT( 3x, i2, ': norm( L - Q'' * A ) / ( M * norm(A) * EPS )' )
915  9947 FORMAT( 3x, i2, ': norm( R - A * Q'' ) / ( N * norm(A) * EPS )' )
916  9946 FORMAT( 3x, i2, ': norm( I - Q''*Q ) / ( M * EPS )' )
917  9945 FORMAT( 3x, i2, ': norm( I - Q*Q'' ) / ( N * EPS )' )
918  9944 FORMAT( 3x, i2, ': norm( Q*C - Q*C ) / ', '( ', a1,
919  $ ' * norm(C) * EPS )' )
920  9943 FORMAT( 3x, i2, ': norm( C*Q - C*Q ) / ', '( ', a1,
921  $ ' * norm(C) * EPS )' )
922  9942 FORMAT( 3x, i2, ': norm( Q''*C - Q''*C )/ ', '( ', a1,
923  $ ' * norm(C) * EPS )' )
924  9941 FORMAT( 3x, i2, ': norm( C*Q'' - C*Q'' )/ ', '( ', a1,
925  $ ' * norm(C) * EPS )' )
926  9940 FORMAT( 3x, i2, ': norm(svd(A) - svd(R)) / ',
927  $ '( M * norm(svd(R)) * EPS )' )
928  9939 FORMAT( 3x, i2, ': norm( A*P - Q*R ) / ( M * norm(A) * EPS )'
929  $ )
930  9938 FORMAT( 3x, i2, ': norm( I - Q''*Q ) / ( M * EPS )' )
931  9937 FORMAT( 3x, i2, ': norm( A - R*Q ) / ( M * norm(A) * EPS )'
932  $ )
933  9935 FORMAT( 3x, i2, ': norm( B - A * X ) / ',
934  $ '( max(M,N) * norm(A) * norm(X) * EPS )' )
935  9934 FORMAT( 3x, i2, ': norm( (A*X-B)'' *A ) / ',
936  $ '( max(M,N,NRHS) * norm(A) * norm(B) * EPS )' )
937  9933 FORMAT( 3x, i2, ': norm(svd(A)-svd(R)) / ',
938  $ '( min(M,N) * norm(svd(R)) * EPS )' )
939  9932 FORMAT( 3x, i2, ': Check if X is in the row space of A or A''' )
940  9931 FORMAT( 3x, i2, ': norm( (A*X-B)'' *A ) / ',
941  $ '( max(M,N,NRHS) * norm(A) * norm(B) * EPS )', / 7x,
942  $ 'if TRANS=''N'.GE.' and MN or TRANS=''T'.LT.' and MN, ',
943  $ 'otherwise', / 7x,
944  $ 'check if X is in the row space of A or A'' ',
945  $ '(overdetermined case)' )
946  9929 FORMAT( ' Test ratios (1-3: ', a1, 'TZRZF):' )
947  9920 FORMAT( 3x, ' 7-10: same as 3-6', 3x, ' 11-14: same as 3-6' )
948  9921 FORMAT( ' Test ratios:', / ' (1-2: ', a1, 'GELS, 3-6: ', a1,
949  $ 'GELSY, 7-10: ', a1, 'GELSS, 11-14: ', a1, 'GELSD)' )
950  9928 FORMAT( 7x, 'where ALPHA = ( 1 + SQRT( 17 ) ) / 8' )
951  9927 FORMAT( 3x, i2, ': ABS( Largest element in L )', / 12x,
952  $ ' - ( 1 / ( 1 - ALPHA ) ) + THRESH' )
953  9926 FORMAT( 3x, i2, ': Largest 2-Norm of 2-by-2 pivots', / 12x,
954  $ ' - ( ( 1 + ALPHA ) / ( 1 - ALPHA ) ) + THRESH' )
955  8011 FORMAT(3x,i2,': norm( R - Q''*A ) / ( M * norm(A) * EPS )' )
956  8012 FORMAT(3x,i2,': norm( I - Q''*Q ) / ( M * EPS )' )
957  8013 FORMAT(3x,i2,': norm( Q*C - Q*C ) / ( M * norm(C) * EPS )' )
958  8014 FORMAT(3x,i2,': norm( Q''*C - Q''*C ) / ( M * norm(C) * EPS )')
959  8015 FORMAT(3x,i2,': norm( C*Q - C*Q ) / ( M * norm(C) * EPS )' )
960  8016 FORMAT(3x,i2,': norm( C*Q'' - C*Q'' ) / ( M * norm(C) * EPS )')
961  8017 FORMAT(3x,i2,': norm( R - Q''*A ) / ( (M+N) * norm(A) * EPS )' )
962  8018 FORMAT(3x,i2,': norm( I - Q''*Q ) / ( (M+N) * EPS )' )
963  8019 FORMAT(3x,i2,': norm( Q*C - Q*C ) / ( (M+N) * norm(C) * EPS )' )
964  8020 FORMAT(3x,i2,
965  $ ': norm( Q''*C - Q''*C ) / ( (M+N) * norm(C) * EPS )')
966  8021 FORMAT(3x,i2,': norm( C*Q - C*Q ) / ( (M+N) * norm(C) * EPS )' )
967  8022 FORMAT(3x,i2,
968  $ ': norm( C*Q'' - C*Q'' ) / ( (M+N) * norm(C) * EPS )')
969 *
970  RETURN
971 *
972 * End of ALAHD
973 *
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
logical function lsamen(N, CA, CB)
LSAMEN
Definition: lsamen.f:76
subroutine alareq ( character*3  PATH,
integer  NMATS,
logical, dimension( * )  DOTYPE,
integer  NTYPES,
integer  NIN,
integer  NOUT 
)

ALAREQ

Purpose:
 ALAREQ handles input for the LAPACK test program.  It is called
 to evaluate the input line which requested NMATS matrix types for
 PATH.  The flow of control is as follows:

 If NMATS = NTYPES then
    DOTYPE(1:NTYPES) = .TRUE.
 else
    Read the next input line for NMATS matrix types
    Set DOTYPE(I) = .TRUE. for each valid type I
 endif
Parameters
[in]PATH
          PATH is CHARACTER*3
          An LAPACK path name for testing.
[in]NMATS
          NMATS is INTEGER
          The number of matrix types to be used in testing this path.
[out]DOTYPE
          DOTYPE is LOGICAL array, dimension (NTYPES)
          The vector of flags indicating if each type will be tested.
[in]NTYPES
          NTYPES is INTEGER
          The maximum number of matrix types for this path.
[in]NIN
          NIN is INTEGER
          The unit number for input.  NIN >= 1.
[in]NOUT
          NOUT is INTEGER
          The unit number for output.  NOUT >= 1.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 92 of file alareq.f.

92 *
93 * -- LAPACK test routine (version 3.4.0) --
94 * -- LAPACK is a software package provided by Univ. of Tennessee, --
95 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
96 * November 2011
97 *
98 * .. Scalar Arguments ..
99  CHARACTER*3 path
100  INTEGER nin, nmats, nout, ntypes
101 * ..
102 * .. Array Arguments ..
103  LOGICAL dotype( * )
104 * ..
105 *
106 * =====================================================================
107 *
108 * .. Local Scalars ..
109  LOGICAL firstt
110  CHARACTER c1
111  CHARACTER*10 intstr
112  CHARACTER*80 line
113  INTEGER i, i1, ic, j, k, lenp, nt
114 * ..
115 * .. Local Arrays ..
116  INTEGER nreq( 100 )
117 * ..
118 * .. Intrinsic Functions ..
119  INTRINSIC len
120 * ..
121 * .. Data statements ..
122  DATA intstr / '0123456789' /
123 * ..
124 * .. Executable Statements ..
125 *
126  IF( nmats.GE.ntypes ) THEN
127 *
128 * Test everything if NMATS >= NTYPES.
129 *
130  DO 10 i = 1, ntypes
131  dotype( i ) = .true.
132  10 CONTINUE
133  ELSE
134  DO 20 i = 1, ntypes
135  dotype( i ) = .false.
136  20 CONTINUE
137  firstt = .true.
138 *
139 * Read a line of matrix types if 0 < NMATS < NTYPES.
140 *
141  IF( nmats.GT.0 ) THEN
142  READ( nin, fmt = '(A80)', end = 90 )line
143  lenp = len( line )
144  i = 0
145  DO 60 j = 1, nmats
146  nreq( j ) = 0
147  i1 = 0
148  30 CONTINUE
149  i = i + 1
150  IF( i.GT.lenp ) THEN
151  IF( j.EQ.nmats .AND. i1.GT.0 ) THEN
152  GO TO 60
153  ELSE
154  WRITE( nout, fmt = 9995 )line
155  WRITE( nout, fmt = 9994 )nmats
156  GO TO 80
157  END IF
158  END IF
159  IF( line( i: i ).NE.' ' .AND. line( i: i ).NE.',' ) THEN
160  i1 = i
161  c1 = line( i1: i1 )
162 *
163 * Check that a valid integer was read
164 *
165  DO 40 k = 1, 10
166  IF( c1.EQ.intstr( k: k ) ) THEN
167  ic = k - 1
168  GO TO 50
169  END IF
170  40 CONTINUE
171  WRITE( nout, fmt = 9996 )i, line
172  WRITE( nout, fmt = 9994 )nmats
173  GO TO 80
174  50 CONTINUE
175  nreq( j ) = 10*nreq( j ) + ic
176  GO TO 30
177  ELSE IF( i1.GT.0 ) THEN
178  GO TO 60
179  ELSE
180  GO TO 30
181  END IF
182  60 CONTINUE
183  END IF
184  DO 70 i = 1, nmats
185  nt = nreq( i )
186  IF( nt.GT.0 .AND. nt.LE.ntypes ) THEN
187  IF( dotype( nt ) ) THEN
188  IF( firstt )
189  $ WRITE( nout, fmt = * )
190  firstt = .false.
191  WRITE( nout, fmt = 9997 )nt, path
192  END IF
193  dotype( nt ) = .true.
194  ELSE
195  WRITE( nout, fmt = 9999 )path, nt, ntypes
196  9999 FORMAT( ' *** Invalid type request for ', a3, ', type ',
197  $ i4, ': must satisfy 1 <= type <= ', i2 )
198  END IF
199  70 CONTINUE
200  80 CONTINUE
201  END IF
202  RETURN
203 *
204  90 CONTINUE
205  WRITE( nout, fmt = 9998 )path
206  9998 FORMAT( /' *** End of file reached when trying to read matrix ',
207  $ 'types for ', a3, /' *** Check that you are requesting the',
208  $ ' right number of types for each path', / )
209  9997 FORMAT( ' *** Warning: duplicate request of matrix type ', i2,
210  $ ' for ', a3 )
211  9996 FORMAT( //' *** Invalid integer value in column ', i2,
212  $ ' of input', ' line:', /a79 )
213  9995 FORMAT( //' *** Not enough matrix types on input line', /a79 )
214  9994 FORMAT( ' ==> Specify ', i4, ' matrix types on this line or ',
215  $ 'adjust NTYPES on previous line' )
216  WRITE( nout, fmt = * )
217  stop
218 *
219 * End of ALAREQ
220 *
subroutine alasum ( character*3  TYPE,
integer  NOUT,
integer  NFAIL,
integer  NRUN,
integer  NERRS 
)

ALASUM

Purpose:
 ALASUM prints a summary of results from one of the -CHK- routines.
Parameters
[in]TYPE
          TYPE is CHARACTER*3
          The LAPACK path name.
[in]NOUT
          NOUT is INTEGER
          The unit number on which results are to be printed.
          NOUT >= 0.
[in]NFAIL
          NFAIL is INTEGER
          The number of tests which did not pass the threshold ratio.
[in]NRUN
          NRUN is INTEGER
          The total number of tests.
[in]NERRS
          NERRS is INTEGER
          The number of error messages recorded.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 75 of file alasum.f.

75 *
76 * -- LAPACK test routine (version 3.4.0) --
77 * -- LAPACK is a software package provided by Univ. of Tennessee, --
78 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
79 * November 2011
80 *
81 * .. Scalar Arguments ..
82  CHARACTER*3 type
83  INTEGER nfail, nout, nrun, nerrs
84 * ..
85 *
86 * =====================================================================
87 *
88 * .. Executable Statements ..
89 *
90  IF( nfail.GT.0 ) THEN
91  WRITE( nout, fmt = 9999 )TYPE, nfail, nrun
92  ELSE
93  WRITE( nout, fmt = 9998 )TYPE, nrun
94  END IF
95  IF( nerrs.GT.0 ) THEN
96  WRITE( nout, fmt = 9997 )nerrs
97  END IF
98 *
99  9999 FORMAT( 1x, a3, ': ', i6, ' out of ', i6,
100  $ ' tests failed to pass the threshold' )
101  9998 FORMAT( /1x, 'All tests for ', a3,
102  $ ' routines passed the threshold ( ', i6, ' tests run)' )
103  9997 FORMAT( 6x, i6, ' error messages recorded' )
104  RETURN
105 *
106 * End of ALASUM
107 *
subroutine alasvm ( character*3  TYPE,
integer  NOUT,
integer  NFAIL,
integer  NRUN,
integer  NERRS 
)

ALASVM

Purpose:
 ALASVM prints a summary of results from one of the -DRV- routines.
Parameters
[in]TYPE
          TYPE is CHARACTER*3
          The LAPACK path name.
[in]NOUT
          NOUT is INTEGER
          The unit number on which results are to be printed.
          NOUT >= 0.
[in]NFAIL
          NFAIL is INTEGER
          The number of tests which did not pass the threshold ratio.
[in]NRUN
          NRUN is INTEGER
          The total number of tests.
[in]NERRS
          NERRS is INTEGER
          The number of error messages recorded.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 75 of file alasvm.f.

75 *
76 * -- LAPACK test routine (version 3.4.0) --
77 * -- LAPACK is a software package provided by Univ. of Tennessee, --
78 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
79 * November 2011
80 *
81 * .. Scalar Arguments ..
82  CHARACTER*3 type
83  INTEGER nfail, nout, nrun, nerrs
84 * ..
85 *
86 * =====================================================================
87 *
88 * .. Executable Statements ..
89 *
90  IF( nfail.GT.0 ) THEN
91  WRITE( nout, fmt = 9999 )TYPE, nfail, nrun
92  ELSE
93  WRITE( nout, fmt = 9998 )TYPE, nrun
94  END IF
95  IF( nerrs.GT.0 ) THEN
96  WRITE( nout, fmt = 9997 )nerrs
97  END IF
98 *
99  9999 FORMAT( 1x, a3, ' drivers: ', i6, ' out of ', i6,
100  $ ' tests failed to pass the threshold' )
101  9998 FORMAT( /1x, 'All tests for ', a3, ' drivers passed the ',
102  $ 'threshold ( ', i6, ' tests run)' )
103  9997 FORMAT( 14x, i6, ' error messages recorded' )
104  RETURN
105 *
106 * End of ALASVM
107 *
subroutine icopy ( integer  N,
integer, dimension( * )  SX,
integer  INCX,
integer, dimension( * )  SY,
integer  INCY 
)

ICOPY

Purpose:
 ICOPY copies an integer vector x to an integer vector y.
 Uses unrolled loops for increments equal to 1.
Parameters
[in]N
          N is INTEGER
          The length of the vectors SX and SY.
[in]SX
          SX is INTEGER array, dimension (1+(N-1)*abs(INCX))
          The vector X.
[in]INCX
          INCX is INTEGER
          The spacing between consecutive elements of SX.
[out]SY
          SY is INTEGER array, dimension (1+(N-1)*abs(INCY))
          The vector Y.
[in]INCY
          INCY is INTEGER
          The spacing between consecutive elements of SY.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 77 of file icopy.f.

77 *
78 * -- LAPACK test routine (version 3.4.0) --
79 * -- LAPACK is a software package provided by Univ. of Tennessee, --
80 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
81 * November 2011
82 *
83 * .. Scalar Arguments ..
84  INTEGER incx, incy, n
85 * ..
86 * .. Array Arguments ..
87  INTEGER sx( * ), sy( * )
88 * ..
89 *
90 * =====================================================================
91 *
92 * .. Local Scalars ..
93  INTEGER i, ix, iy, m, mp1
94 * ..
95 * .. Intrinsic Functions ..
96  INTRINSIC mod
97 * ..
98 * .. Executable Statements ..
99 *
100  IF( n.LE.0 )
101  $ RETURN
102  IF( incx.EQ.1 .AND. incy.EQ.1 )
103  $ GO TO 20
104 *
105 * Code for unequal increments or equal increments not equal to 1
106 *
107  ix = 1
108  iy = 1
109  IF( incx.LT.0 )
110  $ ix = ( -n+1 )*incx + 1
111  IF( incy.LT.0 )
112  $ iy = ( -n+1 )*incy + 1
113  DO 10 i = 1, n
114  sy( iy ) = sx( ix )
115  ix = ix + incx
116  iy = iy + incy
117  10 CONTINUE
118  RETURN
119 *
120 * Code for both increments equal to 1
121 *
122 * Clean-up loop
123 *
124  20 CONTINUE
125  m = mod( n, 7 )
126  IF( m.EQ.0 )
127  $ GO TO 40
128  DO 30 i = 1, m
129  sy( i ) = sx( i )
130  30 CONTINUE
131  IF( n.LT.7 )
132  $ RETURN
133  40 CONTINUE
134  mp1 = m + 1
135  DO 50 i = mp1, n, 7
136  sy( i ) = sx( i )
137  sy( i+1 ) = sx( i+1 )
138  sy( i+2 ) = sx( i+2 )
139  sy( i+3 ) = sx( i+3 )
140  sy( i+4 ) = sx( i+4 )
141  sy( i+5 ) = sx( i+5 )
142  sy( i+6 ) = sx( i+6 )
143  50 CONTINUE
144  RETURN
145 *
146 * End of ICOPY
147 *

Here is the caller graph for this function:

integer function ilaenv ( integer  ISPEC,
character*( * )  NAME,
character*( * )  OPTS,
integer  N1,
integer  N2,
integer  N3,
integer  N4 
)

ILAENV

Purpose:
 ILAENV returns problem-dependent parameters for the local
 environment.  See ISPEC for a description of the parameters.

 In this version, the problem-dependent parameters are contained in
 the integer array IPARMS in the common block CLAENV and the value
 with index ISPEC is copied to ILAENV.  This version of ILAENV is
 to be used in conjunction with XLAENV in TESTING and TIMING.
Parameters
[in]ISPEC
          ISPEC is INTEGER
          Specifies the parameter to be returned as the value of
          ILAENV.
          = 1: the optimal blocksize; if this value is 1, an unblocked
               algorithm will give the best performance.
          = 2: the minimum block size for which the block routine
               should be used; if the usable block size is less than
               this value, an unblocked routine should be used.
          = 3: the crossover point (in a block routine, for N less
               than this value, an unblocked routine should be used)
          = 4: the number of shifts, used in the nonsymmetric
               eigenvalue routines
          = 5: the minimum column dimension for blocking to be used;
               rectangular blocks must have dimension at least k by m,
               where k is given by ILAENV(2,...) and m by ILAENV(5,...)
          = 6: the crossover point for the SVD (when reducing an m by n
               matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds
               this value, a QR factorization is used first to reduce
               the matrix to a triangular form.)
          = 7: the number of processors
          = 8: the crossover point for the multishift QR and QZ methods
               for nonsymmetric eigenvalue problems.
          = 9: maximum size of the subproblems at the bottom of the
               computation tree in the divide-and-conquer algorithm
          =10: ieee NaN arithmetic can be trusted not to trap
          =11: infinity arithmetic can be trusted not to trap

          Other specifications (up to 100) can be added later.
[in]NAME
          NAME is CHARACTER*(*)
          The name of the calling subroutine.
[in]OPTS
          OPTS is CHARACTER*(*)
          The character options to the subroutine NAME, concatenated
          into a single character string.  For example, UPLO = 'U',
          TRANS = 'T', and DIAG = 'N' for a triangular routine would
          be specified as OPTS = 'UTN'.
[in]N1
          N1 is INTEGER
[in]N2
          N2 is INTEGER
[in]N3
          N3 is INTEGER
[in]N4
          N4 is INTEGER

          Problem dimensions for the subroutine NAME; these may not all
          be required.
Returns
ILAENV
          ILAENV is INTEGER
          >= 0: the value of the parameter specified by ISPEC
          < 0:  if ILAENV = -k, the k-th argument had an illegal value.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011
Further Details:
  The following conventions have been used when calling ILAENV from the
  LAPACK routines:
  1)  OPTS is a concatenation of all of the character options to
      subroutine NAME, in the same order that they appear in the
      argument list for NAME, even if they are not used in determining
      the value of the parameter specified by ISPEC.
  2)  The problem dimensions N1, N2, N3, N4 are specified in the order
      that they appear in the argument list for NAME.  N1 is used
      first, N2 second, and so on, and unused problem dimensions are
      passed a value of -1.
  3)  The parameter value returned by ILAENV is checked for validity in
      the calling subroutine.  For example, ILAENV is used to retrieve
      the optimal blocksize for STRTRI as follows:

      NB = ILAENV( 1, 'STRTRI', UPLO // DIAG, N, -1, -1, -1 )
      IF( NB.LE.1 ) NB = MAX( 1, N )

Definition at line 152 of file ilaenv.f.

152 *
153 * -- LAPACK test routine (version 3.4.0) --
154 * -- LAPACK is a software package provided by Univ. of Tennessee, --
155 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
156 * November 2011
157 *
158 * .. Scalar Arguments ..
159  CHARACTER*( * ) name, opts
160  INTEGER ispec, n1, n2, n3, n4
161 * ..
162 *
163 * =====================================================================
164 *
165 * .. Intrinsic Functions ..
166  INTRINSIC int, min, real
167 * ..
168 * .. External Functions ..
169  INTEGER ieeeck
170  EXTERNAL ieeeck
171 * ..
172 * .. Arrays in Common ..
173  INTEGER iparms( 100 )
174 * ..
175 * .. Common blocks ..
176  COMMON / claenv / iparms
177 * ..
178 * .. Save statement ..
179  SAVE / claenv /
180 * ..
181 * .. Executable Statements ..
182 *
183  IF( ispec.GE.1 .AND. ispec.LE.5 ) THEN
184 *
185 * Return a value from the common block.
186 *
187  ilaenv = iparms( ispec )
188 *
189  ELSE IF( ispec.EQ.6 ) THEN
190 *
191 * Compute SVD crossover point.
192 *
193  ilaenv = int( REAL( MIN( N1, N2 ) )*1.6e0 )
194 *
195  ELSE IF( ispec.GE.7 .AND. ispec.LE.9 ) THEN
196 *
197 * Return a value from the common block.
198 *
199  ilaenv = iparms( ispec )
200 *
201  ELSE IF( ispec.EQ.10 ) THEN
202 *
203 * IEEE NaN arithmetic can be trusted not to trap
204 *
205 C ILAENV = 0
206  ilaenv = 1
207  IF( ilaenv.EQ.1 ) THEN
208  ilaenv = ieeeck( 1, 0.0, 1.0 )
209  END IF
210 *
211  ELSE IF( ispec.EQ.11 ) THEN
212 *
213 * Infinity arithmetic can be trusted not to trap
214 *
215 C ILAENV = 0
216  ilaenv = 1
217  IF( ilaenv.EQ.1 ) THEN
218  ilaenv = ieeeck( 0, 0.0, 1.0 )
219  END IF
220 *
221  ELSE
222 *
223 * Invalid value for ISPEC
224 *
225  ilaenv = -1
226  END IF
227 *
228  RETURN
229 *
230 * End of ILAENV
231 *
integer function ieeeck(ISPEC, ZERO, ONE)
Definition: tstiee.f:626
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83

Here is the call graph for this function:

subroutine xlaenv ( integer  ISPEC,
integer  NVALUE 
)

XLAENV

Purpose:
 XLAENV sets certain machine- and problem-dependent quantities
 which will later be retrieved by ILAENV.
Parameters
[in]ISPEC
          ISPEC is INTEGER
          Specifies the parameter to be set in the COMMON array IPARMS.
          = 1: the optimal blocksize; if this value is 1, an unblocked
               algorithm will give the best performance.
          = 2: the minimum block size for which the block routine
               should be used; if the usable block size is less than
               this value, an unblocked routine should be used.
          = 3: the crossover point (in a block routine, for N less
               than this value, an unblocked routine should be used)
          = 4: the number of shifts, used in the nonsymmetric
               eigenvalue routines
          = 5: the minimum column dimension for blocking to be used;
               rectangular blocks must have dimension at least k by m,
               where k is given by ILAENV(2,...) and m by ILAENV(5,...)
          = 6: the crossover point for the SVD (when reducing an m by n
               matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds
               this value, a QR factorization is used first to reduce
               the matrix to a triangular form)
          = 7: the number of processors
          = 8: another crossover point, for the multishift QR and QZ
               methods for nonsymmetric eigenvalue problems.
          = 9: maximum size of the subproblems at the bottom of the
               computation tree in the divide-and-conquer algorithm
               (used by xGELSD and xGESDD)
          =10: ieee NaN arithmetic can be trusted not to trap
          =11: infinity arithmetic can be trusted not to trap
[in]NVALUE
          NVALUE is INTEGER
          The value of the parameter specified by ISPEC.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 80 of file xlaenv.f.

80 *
81 * -- LAPACK test routine (version 3.4.0) --
82 * -- LAPACK is a software package provided by Univ. of Tennessee, --
83 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
84 * November 2011
85 *
86 * .. Scalar Arguments ..
87  INTEGER ispec, nvalue
88 * ..
89 *
90 * =====================================================================
91 *
92 * .. Arrays in Common ..
93  INTEGER iparms( 100 )
94 * ..
95 * .. Common blocks ..
96  COMMON / claenv / iparms
97 * ..
98 * .. Save statement ..
99  SAVE / claenv /
100 * ..
101 * .. Executable Statements ..
102 *
103  IF( ispec.GE.1 .AND. ispec.LE.9 ) THEN
104  iparms( ispec ) = nvalue
105  END IF
106 *
107  RETURN
108 *
109 * End of XLAENV
110 *