1
        2
        3
        4
        5
        6
        7
        8
        9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      111
      112
      113
      114
      115
      116
      117
      118
      119
      120
      121
      122
      123
      124
      125
      126
      127
      128
      129
      130
      131
      132
      133
      134
      135
      136
      137
      138
      139
      140
      141
      142
      143
      144
      145
      146
      147
      148
      149
      150
      151
      152
      153
      154
      155
      156
      157
      158
      159
      160
      161
      162
      163
      164
      165
      166
      167
      168
      169
      170
      171
      172
      173
      174
      175
      176
      177
      178
      179
      180
      181
      182
      183
      184
      185
      186
      187
      188
      189
      190
      191
      192
      193
      194
      195
      196
      197
      198
      199
      200
      201
      202
      203
      204
      205
      206
      207
      208
      209
      210
      211
      212
      213
      214
      215
      216
      217
      218
      219
      220
      221
      222
      223
      224
      225
      226
      227
      228
      229
      230
      231
      232
      233
      234
      235
      236
      237
      238
      239
      240
      241
      242
      243
      244
      245
      246
      247
      248
      249
      250
      251
      252
      253
      254
      255
      256
      257
      258
      259
      260
      261
      262
      263
      264
      265
      266
      267
      268
      269
      270
      271
      272
      273
      274
      275
      276
      277
      278
      279
      280
      281
      282
      283
      284
      285
      286
      287
      288
      289
      290
      291
      292
      293
      294
      295
      296
      297
      298
      299
      300
      301
      302
      303
      304
      305
      306
      307
      308
      309
      310
      311
      312
      313
      314
      315
      316
      317
      318
      319
      320
      321
      322
      323
      324
      325
      326
      327
      328
      329
      330
      331
      332
      333
      334
      335
      336
      337
      338
      339
      340
      341
      342
      343
      344
      345
      346
      347
      348
      349
      350
      351
      352
      353
      354
      355
      356
      357
      358
      359
      360
      361
      362
      363
      364
      365
      366
      367
      368
      369
      370
      371
      372
      373
      374
      375
      376
      377
      378
      379
      380
      381
      382
      383
      384
      385
      386
      387
      388
      389
      390
      391
      392
      393
      394
      395
      396
      397
      398
      399
      400
      401
      402
      403
      404
      405
      406
      407
      408
      409
      410
      411
      412
      413
      414
      415
      416
      417
      418
      419
      420
      421
      422
      423
      424
      425
      426
      427
      428
      429
      430
      431
      432
      433
      434
      435
      436
      437
      438
      439
      440
      441
      442
      443
      444
      445
      446
      447
      448
      449
      450
      451
      452
      453
      454
      455
      456
      457
      458
      459
      460
      461
      462
      463
      464
      465
      466
      467
      468
      469
      470
      471
      472
      473
      474
      475
      476
      477
      478
      479
      480
      481
      482
      483
      484
      485
      486
      487
      488
      489
      490
      491
      492
      493
      494
      495
      496
      497
      498
      499
      500
      501
      502
      503
      504
      505
      506
      507
      508
      509
      510
      511
      512
      513
      514
      515
      516
      517
      518
      519
      520
      521
      522
      523
      524
      525
      526
      527
      528
      529
      530
      531
      532
      533
      534
      535
      536
      537
      538
      539
      540
      541
      542
      543
      544
      545
      546
      547
      548
      549
      550
      551
      552
      553
      554
      555
      556
      557
      558
      559
      560
      561
      562
      563
      564
      565
      566
      567
      568
      569
      570
      571
      572
      573
      574
      575
      576
      577
      578
      579
      580
      581
      582
      583
      584
      585
      586
      587
      588
      589
      590
      591
      592
      593
      594
      595
      596
      597
      598
      599
      600
      601
      602
      603
      604
      605
      606
      607
      608
      609
      610
      611
      612
      613
      614
      615
      616
      617
      618
      619
      620
      621
      622
      623
      624
      625
      626
      627
      628
      629
      630
      631
      632
      633
      634
      635
      636
      637
      638
      639
      640
      641
      642
      643
      644
      645
      646
      647
      648
      649
      650
      651
      652
      653
      654
      655
      656
      657
      658
      659
      660
      661
      662
      663
      664
      665
      666
      667
      668
      669
      670
      671
      672
      673
      674
      675
      676
      677
      678
      679
      680
      681
      682
      683
      684
      685
      686
      687
      688
      689
      690
      691
      692
      693
      694
      695
      696
      697
      698
      699
      700
      701
      702
      703
      704
      705
      706
      707
      708
      709
      710
      711
      712
      713
      714
      715
      716
      717
      718
      719
      720
      721
      722
      723
      724
      725
      726
      727
      728
      729
      730
      731
      732
      733
      734
      735
      736
      737
      738
      739
      740
      741
      742
      743
      744
      745
      746
      747
      748
      749
      750
      751
      752
      753
      754
      755
      756
      757
      758
      759
      760
      761
      762
      763
      764
      765
      766
      767
      768
      769
      770
      771
      772
      773
      774
      775
      776
      777
      778
      779
      780
      781
      782
      783
      784
      785
      786
      787
      788
      789
      790
      791
      792
      793
      794
      795
      796
      797
      798
      799
      800
      801
      802
      803
      804
      805
      806
      807
      808
      809
      810
      811
      812
      813
      814
      815
      816
      817
      818
      819
      820
      821
      822
      823
      824
      825
      826
      827
      828
      829
      830
      831
      832
      833
      834
      835
      836
      837
      838
      839
      840
      841
      842
      843
      844
      845
      846
      847
      848
      849
      850
      851
      852
      853
      854
      855
      856
      857
      858
      859
      860
      861
      862
      863
      864
      865
      866
      867
      868
      869
      870
      871
      872
      873
      874
      875
      876
      877
      878
      879
      880
      881
      882
      883
      884
      885
      886
      887
      888
      889
      890
      891
      892
      893
      894
      895
      896
      897
      898
      899
      900
      901
      902
      903
      904
      905
      906
      907
      908
      909
      910
      911
      912
      913
      914
      915
      916
      917
      918
      919
      920
      921
      922
      923
      924
      925
      926
      927
      928
      929
      930
      931
      932
      933
      934
      935
      936
      937
      938
      939
      940
      941
      942
      943
      944
      945
      946
      947
      948
      949
      950
      951
      952
      953
      954
      955
      956
      957
      958
      959
      960
      961
      962
      963
      964
      965
      966
      967
      968
      969
      970
      971
      972
      973
      974
      975
      976
      977
      978
      979
      980
      981
      982
      983
      984
      985
      986
      987
      988
      989
      990
      991
      992
      993
      994
      995
      996
      997
      998
      999
     1000
     1001
     1002
     1003
     1004
     1005
     1006
     1007
     1008
     1009
     1010
     1011
     1012
     1013
     1014
     1015
     1016
     1017
     1018
     1019
     1020
     1021
     1022
     1023
     1024
     1025
     1026
     1027
     1028
     1029
     1030
     1031
     1032
     1033
     1034
     1035
     1036
     1037
     1038
     1039
     1040
     1041
     1042
     1043
     1044
     1045
     1046
     1047
     1048
     1049
     1050
     1051
     1052
     1053
     1054
     1055
     1056
     1057
     1058
     1059
     1060
     1061
     1062
     1063
     1064
     1065
     1066
     1067
     1068
     1069
     1070
     1071
     1072
     1073
     1074
     1075
     1076
     1077
     1078
     1079
     1080
     1081
     1082
     1083
     1084
      SUBROUTINE DCHKHSNSIZESNNNTYPESDOTYPEISEEDTHRESH,
     $                   NOUNITALDAHT1T2ULDUZUZWR1,
     $                   WI1WR3WI3EVECTLEVECTREVECTYEVECTX,
     $                   UUTAUWORKNWORKIWORKSELECTRESULT,
     $                   INFO )
*
*  -- LAPACK test routine (version 3.1.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     February 2007
*
*     .. Scalar Arguments ..
      INTEGER            INFOLDALDUNOUNITNSIZESNTYPESNWORK
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE* ), SELECT* )
      INTEGER            ISEED4 ), IWORK* ), NN* )
      DOUBLE PRECISION   ALDA* ), EVECTLLDU* ),
     $                   EVECTRLDU* ), EVECTXLDU* ),
     $                   EVECTYLDU* ), HLDA* ), RESULT14 ),
     $                   T1LDA* ), T2LDA* ), TAU* ),
     $                   ULDU* ), UULDU* ), UZLDU* ),
     $                   WI1* ), WI3* ), WORK* ), WR1* ),
     $                   WR3* ), ZLDU* )
*     ..
*
*  Purpose
*  =======
*
*     DCHKHS  checks the nonsymmetric eigenvalue problem routines.
*
*             DGEHRD factors A as  U H U' , where ' means transpose,
*             H is hessenberg, and U is an orthogonal matrix.
*
*             DORGHR generates the orthogonal matrix U.
*
*             DORMHR multiplies a matrix by the orthogonal matrix U.
*
*             DHSEQR factors H as  Z T Z' , where Z is orthogonal and
*             T is "quasi-triangular", and the eigenvalue vector W.
*
*             DTREVC computes the left and right eigenvector matrices
*             L and R for T.
*
*             DHSEIN computes the left and right eigenvector matrices
*             Y and X for H, using inverse iteration.
*
*     When DCHKHS is called, a number of matrix "sizes" ("n's") and a
*     number of matrix "types" are specified.  For each size ("n")
*     and each type of matrix, one matrix will be generated and used
*     to test the nonsymmetric eigenroutines.  For each matrix, 14
*     tests will be performed:
*
*     (1)     | A - U H U**T | / ( |A| n ulp )
*
*     (2)     | I - UU**T | / ( n ulp )
*
*     (3)     | H - Z T Z**T | / ( |H| n ulp )
*
*     (4)     | I - ZZ**T | / ( n ulp )
*
*     (5)     | A - UZ H (UZ)**T | / ( |A| n ulp )
*
*     (6)     | I - UZ (UZ)**T | / ( n ulp )
*
*     (7)     | T(Z computed) - T(Z not computed) | / ( |T| ulp )
*
*     (8)     | W(Z computed) - W(Z not computed) | / ( |W| ulp )
*
*     (9)     | TR - RW | / ( |T| |R| ulp )
*
*     (10)    | L**H T - W**H L | / ( |T| |L| ulp )
*
*     (11)    | HX - XW | / ( |H| |X| ulp )
*
*     (12)    | Y**H H - W**H Y | / ( |H| |Y| ulp )
*
*     (13)    | AX - XW | / ( |A| |X| ulp )
*
*     (14)    | Y**H A - W**H Y | / ( |A| |Y| ulp )
*
*     The "sizes" are specified by an array NN(1:NSIZES); the value of
*     each element NN(j) specifies one size.
*     The "types" are specified by a logical array DOTYPE( 1:NTYPES );
*     if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
*     Currently, the list of possible types is:
*
*     (1)  The zero matrix.
*     (2)  The identity matrix.
*     (3)  A (transposed) Jordan block, with 1's on the diagonal.
*
*     (4)  A diagonal matrix with evenly spaced entries
*          1, ..., ULP  and random signs.
*          (ULP = (first number larger than 1) - 1 )
*     (5)  A diagonal matrix with geometrically spaced entries
*          1, ..., ULP  and random signs.
*     (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
*          and random signs.
*
*     (7)  Same as (4), but multiplied by SQRT( overflow threshold )
*     (8)  Same as (4), but multiplied by SQRT( underflow threshold )
*
*     (9)  A matrix of the form  U' T U, where U is orthogonal and
*          T has evenly spaced entries 1, ..., ULP with random signs
*          on the diagonal and random O(1) entries in the upper
*          triangle.
*
*     (10) A matrix of the form  U' T U, where U is orthogonal and
*          T has geometrically spaced entries 1, ..., ULP with random
*          signs on the diagonal and random O(1) entries in the upper
*          triangle.
*
*     (11) A matrix of the form  U' T U, where U is orthogonal and
*          T has "clustered" entries 1, ULP,..., ULP with random
*          signs on the diagonal and random O(1) entries in the upper
*          triangle.
*
*     (12) A matrix of the form  U' T U, where U is orthogonal and
*          T has real or complex conjugate paired eigenvalues randomly
*          chosen from ( ULP, 1 ) and random O(1) entries in the upper
*          triangle.
*
*     (13) A matrix of the form  X' T X, where X has condition
*          SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
*          with random signs on the diagonal and random O(1) entries
*          in the upper triangle.
*
*     (14) A matrix of the form  X' T X, where X has condition
*          SQRT( ULP ) and T has geometrically spaced entries
*          1, ..., ULP with random signs on the diagonal and random
*          O(1) entries in the upper triangle.
*
*     (15) A matrix of the form  X' T X, where X has condition
*          SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
*          with random signs on the diagonal and random O(1) entries
*          in the upper triangle.
*
*     (16) A matrix of the form  X' T X, where X has condition
*          SQRT( ULP ) and T has real or complex conjugate paired
*          eigenvalues randomly chosen from ( ULP, 1 ) and random
*          O(1) entries in the upper triangle.
*
*     (17) Same as (16), but multiplied by SQRT( overflow threshold )
*     (18) Same as (16), but multiplied by SQRT( underflow threshold )
*
*     (19) Nonsymmetric matrix with random entries chosen from (-1,1).
*     (20) Same as (19), but multiplied by SQRT( overflow threshold )
*     (21) Same as (19), but multiplied by SQRT( underflow threshold )
*
*  Arguments
*  ==========
*
*  NSIZES - INTEGER
*           The number of sizes of matrices to use.  If it is zero,
*           DCHKHS does nothing.  It must be at least zero.
*           Not modified.
*
*  NN     - INTEGER array, dimension (NSIZES)
*           An array containing the sizes to be used for the matrices.
*           Zero values will be skipped.  The values must be at least
*           zero.
*           Not modified.
*
*  NTYPES - INTEGER
*           The number of elements in DOTYPE.   If it is zero, DCHKHS
*           does nothing.  It must be at least zero.  If it is MAXTYP+1
*           and NSIZES is 1, then an additional type, MAXTYP+1 is
*           defined, which is to use whatever matrix is in A.  This
*           is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
*           DOTYPE(MAXTYP+1) is .TRUE. .
*           Not modified.
*
*  DOTYPE - LOGICAL array, dimension (NTYPES)
*           If DOTYPE(j) is .TRUE., then for each size in NN a
*           matrix of that size and of type j will be generated.
*           If NTYPES is smaller than the maximum number of types
*           defined (PARAMETER MAXTYP), then types NTYPES+1 through
*           MAXTYP will not be generated.  If NTYPES is larger
*           than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)
*           will be ignored.
*           Not modified.
*
*  ISEED  - INTEGER array, dimension (4)
*           On entry ISEED specifies the seed of the random number
*           generator. The array elements should be between 0 and 4095;
*           if not they will be reduced mod 4096.  Also, ISEED(4) must
*           be odd.  The random number generator uses a linear
*           congruential sequence limited to small integers, and so
*           should produce machine independent random numbers. The
*           values of ISEED are changed on exit, and can be used in the
*           next call to DCHKHS to continue the same random number
*           sequence.
*           Modified.
*
*  THRESH - DOUBLE PRECISION
*           A test will count as "failed" if the "error", computed as
*           described above, exceeds THRESH.  Note that the error
*           is scaled to be O(1), so THRESH should be a reasonably
*           small multiple of 1, e.g., 10 or 100.  In particular,
*           it should not depend on the precision (single vs. double)
*           or the size of the matrix.  It must be at least zero.
*           Not modified.
*
*  NOUNIT - INTEGER
*           The FORTRAN unit number for printing out error messages
*           (e.g., if a routine returns IINFO not equal to 0.)
*           Not modified.
*
*  A      - DOUBLE PRECISION array, dimension (LDA,max(NN))
*           Used to hold the matrix whose eigenvalues are to be
*           computed.  On exit, A contains the last matrix actually
*           used.
*           Modified.
*
*  LDA    - INTEGER
*           The leading dimension of A, H, T1 and T2.  It must be at
*           least 1 and at least max( NN ).
*           Not modified.
*
*  H      - DOUBLE PRECISION array, dimension (LDA,max(NN))
*           The upper hessenberg matrix computed by DGEHRD.  On exit,
*           H contains the Hessenberg form of the matrix in A.
*           Modified.
*
*  T1     - DOUBLE PRECISION array, dimension (LDA,max(NN))
*           The Schur (="quasi-triangular") matrix computed by DHSEQR
*           if Z is computed.  On exit, T1 contains the Schur form of
*           the matrix in A.
*           Modified.
*
*  T2     - DOUBLE PRECISION array, dimension (LDA,max(NN))
*           The Schur matrix computed by DHSEQR when Z is not computed.
*           This should be identical to T1.
*           Modified.
*
*  LDU    - INTEGER
*           The leading dimension of U, Z, UZ and UU.  It must be at
*           least 1 and at least max( NN ).
*           Not modified.
*
*  U      - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The orthogonal matrix computed by DGEHRD.
*           Modified.
*
*  Z      - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The orthogonal matrix computed by DHSEQR.
*           Modified.
*
*  UZ     - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The product of U times Z.
*           Modified.
*
*  WR1    - DOUBLE PRECISION array, dimension (max(NN))
*  WI1    - DOUBLE PRECISION array, dimension (max(NN))
*           The real and imaginary parts of the eigenvalues of A,
*           as computed when Z is computed.
*           On exit, WR1 + WI1*i are the eigenvalues of the matrix in A.
*           Modified.
*
*  WR3    - DOUBLE PRECISION array, dimension (max(NN))
*  WI3    - DOUBLE PRECISION array, dimension (max(NN))
*           Like WR1, WI1, these arrays contain the eigenvalues of A,
*           but those computed when DHSEQR only computes the
*           eigenvalues, i.e., not the Schur vectors and no more of the
*           Schur form than is necessary for computing the
*           eigenvalues.
*           Modified.
*
*  EVECTL - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The (upper triangular) left eigenvector matrix for the
*           matrix in T1.  For complex conjugate pairs, the real part
*           is stored in one row and the imaginary part in the next.
*           Modified.
*
*  EVEZTR - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The (upper triangular) right eigenvector matrix for the
*           matrix in T1.  For complex conjugate pairs, the real part
*           is stored in one column and the imaginary part in the next.
*           Modified.
*
*  EVECTY - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The left eigenvector matrix for the
*           matrix in H.  For complex conjugate pairs, the real part
*           is stored in one row and the imaginary part in the next.
*           Modified.
*
*  EVECTX - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           The right eigenvector matrix for the
*           matrix in H.  For complex conjugate pairs, the real part
*           is stored in one column and the imaginary part in the next.
*           Modified.
*
*  UU     - DOUBLE PRECISION array, dimension (LDU,max(NN))
*           Details of the orthogonal matrix computed by DGEHRD.
*           Modified.
*
*  TAU    - DOUBLE PRECISION array, dimension(max(NN))
*           Further details of the orthogonal matrix computed by DGEHRD.
*           Modified.
*
*  WORK   - DOUBLE PRECISION array, dimension (NWORK)
*           Workspace.
*           Modified.
*
*  NWORK  - INTEGER
*           The number of entries in WORK.  NWORK >= 4*NN(j)*NN(j) + 2.
*
*  IWORK  - INTEGER array, dimension (max(NN))
*           Workspace.
*           Modified.
*
*  SELECT - LOGICAL array, dimension (max(NN))
*           Workspace.
*           Modified.
*
*  RESULT - DOUBLE PRECISION array, dimension (14)
*           The values computed by the fourteen tests described above.
*           The values are currently limited to 1/ulp, to avoid
*           overflow.
*           Modified.
*
*  INFO   - INTEGER
*           If 0, then everything ran OK.
*            -1: NSIZES < 0
*            -2: Some NN(j) < 0
*            -3: NTYPES < 0
*            -6: THRESH < 0
*            -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
*           -14: LDU < 1 or LDU < NMAX.
*           -28: NWORK too small.
*           If  DLATMR, SLATMS, or SLATME returns an error code, the
*               absolute value of it is returned.
*           If 1, then DHSEQR could not find all the shifts.
*           If 2, then the EISPACK code (for small blocks) failed.
*           If >2, then 30*N iterations were not enough to find an
*               eigenvalue or to decompose the problem.
*           Modified.
*
*-----------------------------------------------------------------------
*
*     Some Local Variables and Parameters:
*     ---- ----- --------- --- ----------
*
*     ZERO, ONE       Real 0 and 1.
*     MAXTYP          The number of types defined.
*     MTEST           The number of tests defined: care must be taken
*                     that (1) the size of RESULT, (2) the number of
*                     tests actually performed, and (3) MTEST agree.
*     NTEST           The number of tests performed on this matrix
*                     so far.  This should be less than MTEST, and
*                     equal to it by the last test.  It will be less
*                     if any of the routines being tested indicates
*                     that it could not compute the matrices that
*                     would be tested.
*     NMAX            Largest value in NN.
*     NMATS           The number of matrices generated so far.
*     NERRS           The number of tests which have exceeded THRESH
*                     so far (computed by DLAFTS).
*     COND, CONDS,
*     IMODE           Values to be passed to the matrix generators.
*     ANORM           Norm of A; passed to matrix generators.
*
*     OVFL, UNFL      Overflow and underflow thresholds.
*     ULP, ULPINV     Finest relative precision and its inverse.
*     RTOVFL, RTUNFL,
*     RTULP, RTULPI   Square roots of the previous 4 values.
*
*             The following four arrays decode JTYPE:
*     KTYPE(j)        The general type (1-10) for type "j".
*     KMODE(j)        The MODE value to be passed to the matrix
*                     generator for type "j".
*     KMAGN(j)        The order of magnitude ( O(1),
*                     O(overflow^(1/2) ), O(underflow^(1/2) )
*     KCONDS(j)       Selects whether CONDS is to be 1 or
*                     1/sqrt(ulp).  (0 means irrelevant.)
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ZEROONE
      PARAMETER          ( ZERO = 0.0D0ONE = 1.0D0 )
      INTEGER            MAXTYP
      PARAMETER          ( MAXTYP = 21 )
*     ..
*     .. Local Scalars ..
      LOGICAL            BADNNMATCH
      INTEGER            IIHIIINFOILOIMODEINITYPEJJCOL,
     $                   JJJSIZEJTYPEKMTYPESNN1NERRS,
     $                   NMATSNMAXNSELCNSELRNTESTNTESTT
      DOUBLE PRECISION   ANINVANORMCONDCONDSOVFLRTOVFLRTULP,
     $                   RTULPIRTUNFLTEMP1TEMP2ULPULPINVUNFL
*     ..
*     .. Local Arrays ..
      CHARACTER          ADUMMA1 )
      INTEGER            IDUMMA1 ), IOLDSD4 ), KCONDSMAXTYP ),
     $                   KMAGNMAXTYP ), KMODEMAXTYP ),
     $                   KTYPEMAXTYP )
      DOUBLE PRECISION   DUMMA6 )
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH
      EXTERNAL           DLAMCH
*     ..
*     .. External Subroutines ..
      EXTERNAL           DCOPYDGEHRDDGEMMDGET10DGET22DHSEIN,
     $                   DHSEQRDHST01DLABADDLACPYDLAFTSDLASET,
     $                   DLASUMDLATMEDLATMRDLATMSDORGHRDORMHR,
     $                   DTREVCXERBLA
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          ABSDBLEMAXMINSQRT
*     ..
*     .. Data statements ..
      DATA               KTYPE / 1235*44*66*63*9 /
      DATA               KMAGN / 3*1111234*111112,
     $                   3123 /
      DATA               KMODE / 3*043144431543,
     $                   1555431 /
      DATA               KCONDS / 3*05*04*16*23*0 /
*     ..
*     .. Executable Statements ..
*
*     Check for errors
*
      NTESTT = 0
      INFO = 0
*
      BADNN = .FALSE.
      NMAX = 0
      DO 10 J = 1NSIZES
         NMAX = MAXNMAXNNJ ) )
         IFNNJ ).LT.0 )
     $      BADNN = .TRUE.
   10 CONTINUE
*
*     Check for errors
*
      IFNSIZES.LT.0 ) THEN
         INFO = -1
      ELSE IFBADNN ) THEN
         INFO = -2
      ELSE IFNTYPES.LT.0 ) THEN
         INFO = -3
      ELSE IFTHRESH.LT.ZERO ) THEN
         INFO = -6
      ELSE IFLDA.LE.1 .OR. LDA.LT.NMAX ) THEN
         INFO = -9
      ELSE IFLDU.LE.1 .OR. LDU.LT.NMAX ) THEN
         INFO = -14
      ELSE IF4*NMAX*NMAX+2.GT.NWORK ) THEN
         INFO = -28
      END IF
*
      IFINFO.NE.0 ) THEN
         CALL XERBLA'DCHKHS'-INFO )
         RETURN
      END IF
*
*     Quick return if possible
*
      IFNSIZES.EQ.0 .OR. NTYPES.EQ.0 )
     $   RETURN
*
*     More important constants
*
      UNFL = DLAMCH'Safe minimum' )
      OVFL = DLAMCH'Overflow' )
      CALL DLABADUNFLOVFL )
      ULP = DLAMCH'Epsilon' )*DLAMCH'Base' )
      ULPINV = ONE / ULP
      RTUNFL = SQRTUNFL )
      RTOVFL = SQRTOVFL )
      RTULP = SQRTULP )
      RTULPI = ONE / RTULP
*
*     Loop over sizes, types
*
      NERRS = 0
      NMATS = 0
*
      DO 270 JSIZE = 1NSIZES
         N = NNJSIZE )
         IFN.EQ.0 )
     $      GO TO 270
         N1 = MAX1N )
         ANINV = ONE / DBLEN1 )
*
         IFNSIZES.NE.1 ) THEN
            MTYPES = MINMAXTYPNTYPES )
         ELSE
            MTYPES = MINMAXTYP+1NTYPES )
         END IF
*
         DO 260 JTYPE = 1MTYPES
            IF.NOT.DOTYPEJTYPE ) )
     $         GO TO 260
            NMATS = NMATS + 1
            NTEST = 0
*
*           Save ISEED in case of an error.
*
            DO 20 J = 14
               IOLDSDJ ) = ISEEDJ )
   20       CONTINUE
*
*           Initialize RESULT
*
            DO 30 J = 114
               RESULTJ ) = ZERO
   30       CONTINUE
*
*           Compute "A"
*
*           Control parameters:
*
*           KMAGN  KCONDS  KMODE        KTYPE
*       =1  O(1)   1       clustered 1  zero
*       =2  large  large   clustered 2  identity
*       =3  small          exponential  Jordan
*       =4                 arithmetic   diagonal, (w/ eigenvalues)
*       =5                 random log   symmetric, w/ eigenvalues
*       =6                 random       general, w/ eigenvalues
*       =7                              random diagonal
*       =8                              random symmetric
*       =9                              random general
*       =10                             random triangular
*
            IFMTYPES.GT.MAXTYP )
     $         GO TO 100
*
            ITYPE = KTYPEJTYPE )
            IMODE = KMODEJTYPE )
*
*           Compute norm
*
            GO TO ( 405060 )KMAGNJTYPE )
*
   40       CONTINUE
            ANORM = ONE
            GO TO 70
*
   50       CONTINUE
            ANORM = ( RTOVFL*ULP )*ANINV
            GO TO 70
*
   60       CONTINUE
            ANORM = RTUNFL*N*ULPINV
            GO TO 70
*
   70       CONTINUE
*
            CALL DLASET'Full'LDANZEROZEROALDA )
            IINFO = 0
            COND = ULPINV
*
*           Special Matrices
*
            IFITYPE.EQ.1 ) THEN
*
*              Zero
*
               IINFO = 0
*
            ELSE IFITYPE.EQ.2 ) THEN
*
*              Identity
*
               DO 80 JCOL = 1N
                  AJCOLJCOL ) = ANORM
   80          CONTINUE
*
            ELSE IFITYPE.EQ.3 ) THEN
*
*              Jordan Block
*
               DO 90 JCOL = 1N
                  AJCOLJCOL ) = ANORM
                  IFJCOL.GT.1 )
     $               AJCOLJCOL-1 ) = ONE
   90          CONTINUE
*
            ELSE IFITYPE.EQ.4 ) THEN
*
*              Diagonal Matrix, [Eigen]values Specified
*
               CALL DLATMSNN'S'ISEED'S'WORKIMODECOND,
     $                      ANORM00'N'ALDAWORKN+1 ),
     $                      IINFO )
*
            ELSE IFITYPE.EQ.5 ) THEN
*
*              Symmetric, eigenvalues specified
*
               CALL DLATMSNN'S'ISEED'S'WORKIMODECOND,
     $                      ANORMNN'N'ALDAWORKN+1 ),
     $                      IINFO )
*
            ELSE IFITYPE.EQ.6 ) THEN
*
*              General, eigenvalues specified
*
               IFKCONDSJTYPE ).EQ.1 ) THEN
                  CONDS = ONE
               ELSE IFKCONDSJTYPE ).EQ.2 ) THEN
                  CONDS = RTULPI
               ELSE
                  CONDS = ZERO
               END IF
*
               ADUMMA1 ) = ' '
               CALL DLATMEN'S'ISEEDWORKIMODECONDONE,
     $                      ADUMMA'T''T''T'WORKN+1 ), 4,
     $                      CONDSNNANORMALDAWORK2*N+1 ),
     $                      IINFO )
*
            ELSE IFITYPE.EQ.7 ) THEN
*
*              Diagonal, random eigenvalues
*
               CALL DLATMRNN'S'ISEED'S'WORK6ONEONE,
     $                      'T''N'WORKN+1 ), 1ONE,
     $                      WORK2*N+1 ), 1ONE'N'IDUMMA00,
     $                      ZEROANORM'NO'ALDAIWORKIINFO )
*
            ELSE IFITYPE.EQ.8 ) THEN
*
*              Symmetric, random eigenvalues
*
               CALL DLATMRNN'S'ISEED'S'WORK6ONEONE,
     $                      'T''N'WORKN+1 ), 1ONE,
     $                      WORK2*N+1 ), 1ONE'N'IDUMMANN,
     $                      ZEROANORM'NO'ALDAIWORKIINFO )
*
            ELSE IFITYPE.EQ.9 ) THEN
*
*              General, random eigenvalues
*
               CALL DLATMRNN'S'ISEED'N'WORK6ONEONE,
     $                      'T''N'WORKN+1 ), 1ONE,
     $                      WORK2*N+1 ), 1ONE'N'IDUMMANN,
     $                      ZEROANORM'NO'ALDAIWORKIINFO )
*
            ELSE IFITYPE.EQ.10 ) THEN
*
*              Triangular, random eigenvalues
*
               CALL DLATMRNN'S'ISEED'N'WORK6ONEONE,
     $                      'T''N'WORKN+1 ), 1ONE,
     $                      WORK2*N+1 ), 1ONE'N'IDUMMAN0,
     $                      ZEROANORM'NO'ALDAIWORKIINFO )
*
            ELSE
*
               IINFO = 1
            END IF
*
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'Generator', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               RETURN
            END IF
*
  100       CONTINUE
*
*           Call DGEHRD to compute H and U, do tests.
*
            CALL DLACPY' 'NNALDAHLDA )
*
            NTEST = 1
*
            ILO = 1
            IHI = N
*
            CALL DGEHRDNILOIHIHLDAWORKWORKN+1 ),
     $                   NWORK-NIINFO )
*
            IFIINFO.NE.0 ) THEN
               RESULT1 ) = ULPINV
               WRITENOUNIT, FMT = 9999 )'DGEHRD', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
            DO 120 J = 1N - 1
               UUJ+1J ) = ZERO
               DO 110 I = J + 2N
                  UIJ ) = HIJ )
                  UUIJ ) = HIJ )
                  HIJ ) = ZERO
  110          CONTINUE
  120       CONTINUE
            CALL DCOPYN-1WORK1TAU1 )
            CALL DORGHRNILOIHIULDUWORKWORKN+1 ),
     $                   NWORK-NIINFO )
            NTEST = 2
*
            CALL DHST01NILOIHIALDAHLDAULDUWORK,
     $                   NWORKRESULT1 ) )
*
*           Call DHSEQR to compute T1, T2 and Z, do tests.
*
*           Eigenvalues only (WR3,WI3)
*
            CALL DLACPY' 'NNHLDAT2LDA )
            NTEST = 3
            RESULT3 ) = ULPINV
*
            CALL DHSEQR'E''N'NILOIHIT2LDAWR3WI3UZ,
     $                   LDUWORKNWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DHSEQR(E)', IINFO, N, JTYPE,
     $            IOLDSD
               IFIINFO.LE.N+2 ) THEN
                  INFO = ABSIINFO )
                  GO TO 250
               END IF
            END IF
*
*           Eigenvalues (WR1,WI1) and Full Schur Form (T2)
*
            CALL DLACPY' 'NNHLDAT2LDA )
*
            CALL DHSEQR'S''N'NILOIHIT2LDAWR1WI1UZ,
     $                   LDUWORKNWORKIINFO )
            IFIINFO.NE.0 .AND. IINFO.LE.N+2 ) THEN
               WRITENOUNIT, FMT = 9999 )'DHSEQR(S)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
*           Eigenvalues (WR1,WI1), Schur Form (T1), and Schur vectors
*           (UZ)
*
            CALL DLACPY' 'NNHLDAT1LDA )
            CALL DLACPY' 'NNULDUUZLDA )
*
            CALL DHSEQR'S''V'NILOIHIT1LDAWR1WI1UZ,
     $                   LDUWORKNWORKIINFO )
            IFIINFO.NE.0 .AND. IINFO.LE.N+2 ) THEN
               WRITENOUNIT, FMT = 9999 )'DHSEQR(V)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
*           Compute Z = U' UZ
*
            CALL DGEMM'T''N'NNNONEULDUUZLDUZERO,
     $                  ZLDU )
            NTEST = 8
*
*           Do Tests 3: | H - Z T Z' | / ( |H| n ulp )
*                and 4: | I - Z Z' | / ( n ulp )
*
            CALL DHST01NILOIHIHLDAT1LDAZLDUWORK,
     $                   NWORKRESULT3 ) )
*
*           Do Tests 5: | A - UZ T (UZ)' | / ( |A| n ulp )
*                and 6: | I - UZ (UZ)' | / ( n ulp )
*
            CALL DHST01NILOIHIALDAT1LDAUZLDUWORK,
     $                   NWORKRESULT5 ) )
*
*           Do Test 7: | T2 - T1 | / ( |T| n ulp )
*
            CALL DGET10NNT2LDAT1LDAWORKRESULT7 ) )
*
*           Do Test 8: | W3 - W1 | / ( max(|W1|,|W3|) ulp )
*
            TEMP1 = ZERO
            TEMP2 = ZERO
            DO 130 J = 1N
               TEMP1 = MAXTEMP1ABSWR1J ) )+ABSWI1J ) ),
     $                 ABSWR3J ) )+ABSWI3J ) ) )
               TEMP2 = MAXTEMP2ABSWR1J )-WR3J ) )+
     $                 ABSWR1J )-WR3J ) ) )
  130       CONTINUE
*
            RESULT8 ) = TEMP2 / MAXUNFLULP*MAXTEMP1TEMP2 ) )
*
*           Compute the Left and Right Eigenvectors of T
*
*           Compute the Right eigenvector Matrix:
*
            NTEST = 9
            RESULT9 ) = ULPINV
*
*           Select last max(N/4,1) real, max(N/4,1) complex eigenvectors
*
            NSELC = 0
            NSELR = 0
            J = N
  140       CONTINUE
            IFWI1J ).EQ.ZERO ) THEN
               IFNSELR.LT.MAXN / 41 ) ) THEN
                  NSELR = NSELR + 1
                  SELECTJ ) = .TRUE.
               ELSE
                  SELECTJ ) = .FALSE.
               END IF
               J = J - 1
            ELSE
               IFNSELC.LT.MAXN / 41 ) ) THEN
                  NSELC = NSELC + 1
                  SELECTJ ) = .TRUE.
                  SELECTJ-1 ) = .FALSE.
               ELSE
                  SELECTJ ) = .FALSE.
                  SELECTJ-1 ) = .FALSE.
               END IF
               J = J - 2
            END IF
            IFJ.GT.0 )
     $         GO TO 140
*
            CALL DTREVC'Right''All'SELECTNT1LDADUMMALDU,
     $                   EVECTRLDUNINWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DTREVC(R,A)', IINFO, N,
     $            JTYPE, IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
*           Test 9:  | TR - RW | / ( |T| |R| ulp )
*
            CALL DGET22'N''N''N'NT1LDAEVECTRLDUWR1,
     $                   WI1WORKDUMMA1 ) )
            RESULT9 ) = DUMMA1 )
            IFDUMMA2 ).GT.THRESH ) THEN
               WRITENOUNIT, FMT = 9998 )'Right''DTREVC',
     $            DUMMA( 2 ), N, JTYPE, IOLDSD
            END IF
*
*           Compute selected right eigenvectors and confirm that
*           they agree with previous right eigenvectors
*
            CALL DTREVC'Right''Some'SELECTNT1LDADUMMA,
     $                   LDUEVECTLLDUNINWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DTREVC(R,S)', IINFO, N,
     $            JTYPE, IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
            K = 1
            MATCH = .TRUE.
            DO 170 J = 1N
               IFSELECTJ ) .AND. WI1J ).EQ.ZERO ) THEN
                  DO 150 JJ = 1N
                     IFEVECTRJJJ ).NE.EVECTLJJK ) ) THEN
                        MATCH = .FALSE.
                        GO TO 180
                     END IF
  150             CONTINUE
                  K = K + 1
               ELSE IFSELECTJ ) .AND. WI1J ).NE.ZERO ) THEN
                  DO 160 JJ = 1N
                     IFEVECTRJJJ ).NE.EVECTLJJK ) .OR.
     $                   EVECTRJJJ+1 ).NE.EVECTLJJK+1 ) ) THEN
                        MATCH = .FALSE.
                        GO TO 180
                     END IF
  160             CONTINUE
                  K = K + 2
               END IF
  170       CONTINUE
  180       CONTINUE
            IF.NOT.MATCH )
     $         WRITENOUNIT, FMT = 9997 )'Right''DTREVC', N, JTYPE,
     $         IOLDSD
*
*           Compute the Left eigenvector Matrix:
*
            NTEST = 10
            RESULT10 ) = ULPINV
            CALL DTREVC'Left''All'SELECTNT1LDAEVECTLLDU,
     $                   DUMMALDUNINWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DTREVC(L,A)', IINFO, N,
     $            JTYPE, IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
*           Test 10:  | LT - WL | / ( |T| |L| ulp )
*
            CALL DGET22'Trans''N''Conj'NT1LDAEVECTLLDU,
     $                   WR1WI1WORKDUMMA3 ) )
            RESULT10 ) = DUMMA3 )
            IFDUMMA4 ).GT.THRESH ) THEN
               WRITENOUNIT, FMT = 9998 )'Left''DTREVC', DUMMA( 4 ),
     $            N, JTYPE, IOLDSD
            END IF
*
*           Compute selected left eigenvectors and confirm that
*           they agree with previous left eigenvectors
*
            CALL DTREVC'Left''Some'SELECTNT1LDAEVECTR,
     $                   LDUDUMMALDUNINWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DTREVC(L,S)', IINFO, N,
     $            JTYPE, IOLDSD
               INFO = ABSIINFO )
               GO TO 250
            END IF
*
            K = 1
            MATCH = .TRUE.
            DO 210 J = 1N
               IFSELECTJ ) .AND. WI1J ).EQ.ZERO ) THEN
                  DO 190 JJ = 1N
                     IFEVECTLJJJ ).NE.EVECTRJJK ) ) THEN
                        MATCH = .FALSE.
                        GO TO 220
                     END IF
  190             CONTINUE
                  K = K + 1
               ELSE IFSELECTJ ) .AND. WI1J ).NE.ZERO ) THEN
                  DO 200 JJ = 1N
                     IFEVECTLJJJ ).NE.EVECTRJJK ) .OR.
     $                   EVECTLJJJ+1 ).NE.EVECTRJJK+1 ) ) THEN
                        MATCH = .FALSE.
                        GO TO 220
                     END IF
  200             CONTINUE
                  K = K + 2
               END IF
  210       CONTINUE
  220       CONTINUE
            IF.NOT.MATCH )
     $         WRITENOUNIT, FMT = 9997 )'Left''DTREVC', N, JTYPE,
     $         IOLDSD
*
*           Call DHSEIN for Right eigenvectors of H, do test 11
*
            NTEST = 11
            RESULT11 ) = ULPINV
            DO 230 J = 1N
               SELECTJ ) = .TRUE.
  230       CONTINUE
*
            CALL DHSEIN'Right''Qr''Ninitv'SELECTNHLDA,
     $                   WR3WI3DUMMALDUEVECTXLDUN1IN,
     $                   WORKIWORKIWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DHSEIN(R)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               IFIINFO.LT.0 )
     $            GO TO 250
            ELSE
*
*              Test 11:  | HX - XW | / ( |H| |X| ulp )
*
*                        (from inverse iteration)
*
               CALL DGET22'N''N''N'NHLDAEVECTXLDUWR3,
     $                      WI3WORKDUMMA1 ) )
               IFDUMMA1 ).LT.ULPINV )
     $            RESULT11 ) = DUMMA1 )*ANINV
               IFDUMMA2 ).GT.THRESH ) THEN
                  WRITENOUNIT, FMT = 9998 )'Right''DHSEIN',
     $               DUMMA( 2 ), N, JTYPE, IOLDSD
               END IF
            END IF
*
*           Call DHSEIN for Left eigenvectors of H, do test 12
*
            NTEST = 12
            RESULT12 ) = ULPINV
            DO 240 J = 1N
               SELECTJ ) = .TRUE.
  240       CONTINUE
*
            CALL DHSEIN'Left''Qr''Ninitv'SELECTNHLDAWR3,
     $                   WI3EVECTYLDUDUMMALDUN1INWORK,
     $                   IWORKIWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DHSEIN(L)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               IFIINFO.LT.0 )
     $            GO TO 250
            ELSE
*
*              Test 12:  | YH - WY | / ( |H| |Y| ulp )
*
*                        (from inverse iteration)
*
               CALL DGET22'C''N''C'NHLDAEVECTYLDUWR3,
     $                      WI3WORKDUMMA3 ) )
               IFDUMMA3 ).LT.ULPINV )
     $            RESULT12 ) = DUMMA3 )*ANINV
               IFDUMMA4 ).GT.THRESH ) THEN
                  WRITENOUNIT, FMT = 9998 )'Left''DHSEIN',
     $               DUMMA( 4 ), N, JTYPE, IOLDSD
               END IF
            END IF
*
*           Call DORMHR for Right eigenvectors of A, do test 13
*
            NTEST = 13
            RESULT13 ) = ULPINV
*
            CALL DORMHR'Left''No transpose'NNILOIHIUU,
     $                   LDUTAUEVECTXLDUWORKNWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DORMHR(R)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               IFIINFO.LT.0 )
     $            GO TO 250
            ELSE
*
*              Test 13:  | AX - XW | / ( |A| |X| ulp )
*
*                        (from inverse iteration)
*
               CALL DGET22'N''N''N'NALDAEVECTXLDUWR3,
     $                      WI3WORKDUMMA1 ) )
               IFDUMMA1 ).LT.ULPINV )
     $            RESULT13 ) = DUMMA1 )*ANINV
            END IF
*
*           Call DORMHR for Left eigenvectors of A, do test 14
*
            NTEST = 14
            RESULT14 ) = ULPINV
*
            CALL DORMHR'Left''No transpose'NNILOIHIUU,
     $                   LDUTAUEVECTYLDUWORKNWORKIINFO )
            IFIINFO.NE.0 ) THEN
               WRITENOUNIT, FMT = 9999 )'DORMHR(L)', IINFO, N, JTYPE,
     $            IOLDSD
               INFO = ABSIINFO )
               IFIINFO.LT.0 )
     $            GO TO 250
            ELSE
*
*              Test 14:  | YA - WY | / ( |A| |Y| ulp )
*
*                        (from inverse iteration)
*
               CALL DGET22'C''N''C'NALDAEVECTYLDUWR3,
     $                      WI3WORKDUMMA3 ) )
               IFDUMMA3 ).LT.ULPINV )
     $            RESULT14 ) = DUMMA3 )*ANINV
            END IF
*
*           End of Loop -- Check for RESULT(j) > THRESH
*
  250       CONTINUE
*
            NTESTT = NTESTT + NTEST
            CALL DLAFTS'DHS'NNJTYPENTESTRESULTIOLDSD,
     $                   THRESHNOUNITNERRS )
*
  260    CONTINUE
  270 CONTINUE
*
*     Summary
*
      CALL DLASUM'DHS'NOUNITNERRSNTESTT )
*
      RETURN
*
 9999 FORMAT( ' DCHKHS: ', A, ' returned INFO=', I6, '.', / 9X, 'N=',
     $      I6, ', JTYPE=', I6, ', ISEED=(', 3( I5, ',' ), I5, ')' )
 9998 FORMAT( ' DCHKHS: ', A, ' Eigenvectors from ', A, ' incorrectly ',
     $      'normalized.', / ' Bits of error=', 0P, G10.3, ',', 9X,
     $      'N=', I6, ', JTYPE=', I6, ', ISEED=(', 3( I5, ',' ), I5,
     $      ')' )
 9997 FORMAT( ' DCHKHS: Selected ', A, ' Eigenvectors from ', A,
     $      ' do not match other eigenvectors ', 9X, 'N=', I6,
     $      ', JTYPE=', I6, ', ISEED=(', 3( I5, ',' ), I5, ')' )
*
*     End of DCHKHS
*
      END