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
     1085
     1086
     1087
     1088
     1089
     1090
     1091
     1092
     1093
     1094
     1095
     1096
     1097
     1098
     1099
     1100
     1101
     1102
     1103
     1104
     1105
     1106
     1107
     1108
     1109
     1110
     1111
     1112
     1113
     1114
     1115
     1116
     1117
     1118
     1119
     1120
     1121
     1122
     1123
     1124
     1125
     1126
     1127
     1128
     1129
     1130
     1131
     1132
     1133
     1134
     1135
     1136
     1137
     1138
     1139
     1140
/*
 *   Copyright (c) 2011, Michael Lehn
 *
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *   1) Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2) Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *   3) Neither the name of the FLENS development group nor the names of
 *      its contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Based on
 *
      SUBROUTINE DGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, WI,
     $                   VL, LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM,
     $                   RCONDE, RCONDV, WORK, LWORK, IWORK, INFO )
      SUBROUTINE ZGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, W, VL,
     $                   LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM, RCONDE,
     $                   RCONDV, WORK, LWORK, RWORK, INFO )
 *
 *  -- LAPACK driver routine (version 3.3.1) --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *  -- April 2011                                                      --
 */

#ifndef FLENS_LAPACK_GE_EVX_TCC
#define FLENS_LAPACK_GE_EVX_TCC 1

#include <flens/blas/blas.h>
#include <flens/lapack/lapack.h>

namespace flens { namespace lapack {

//== generic lapack implementation =============================================

namespace generic {

//-- (ge)evx_wsq [worksize query, real variant] --------------------------------

template <typename MA>
Pair<typename GeMatrix<MA>::IndexType>
evx_wsq_impl(bool               computeVL,
             bool               computeVR,
             SENSE::Sense       sense,
             const GeMatrix<MA> &A)
{
    using std::max;

    typedef typename GeMatrix<MA>::ElementType  T;
    typedef typename GeMatrix<MA>::IndexType    IndexType;

    const IndexType n = A.numRows();
    const bool wantSN = (sense==SENSE::None);
    const bool wantSE = (sense==SENSE::EigenvaluesOnly);

    IndexType minWork, maxWork;

    if (n==0) {
        minWork1;
        maxWork1;
    } else {
        maxWork = n + n*ilaenv<T>(1"GEHRD""", n1, n0);

        IndexType hseqrWork;
        if (computeVL) {
            hseqrWork = hseqr_wsq(HSEQR::Schur, HSEQR::NoInit,
                                  IndexType(1), n, A);
        } else if (computeVL) {
            hseqrWork = hseqr_wsq(HSEQR::Schur, HSEQR::NoInit,
                                  IndexType(1), n, A);
        } else {
            if (wantSN) {
                hseqrWork = hseqr_wsq(HSEQR::Eigenvalues, HSEQR::No,
                                      IndexType(1), n, A);
            } else {
                hseqrWork = hseqr_wsq(HSEQR::Schur, HSEQR::No,
                                      IndexType(1), n, A);
            }
        }

        if ((!computeVL) && (!computeVR)) {
            minWork2*n;
            if (!wantSN) {
                minWork = max(minWork, n*n+6*n);
            }
            maxWork = max(maxWork, hseqrWork);
            if (!wantSN) {
                maxWork = max(maxWork, n*n+6*n);
            }
        } else {
            minWork3*n;
            if ((!wantSN) && (!wantSE)) {
                minWork = max(minWork, n*n6*n);
            }
            maxWork = max(maxWork, hseqrWork);
            maxWork = max(maxWork, n+(n-1*ilaenv<T>(1"ORGHR""", n1, n)));
            if ((!wantSN) && (!wantSE)) {
                maxWork = max(maxWork, n*n6*n);
            }
            maxWork = max(maxWork3*n);
        }
        maxWork = max(maxWork, minWork);
    }

    return Pair<typename GeMatrix<MA>::IndexType>(minWork, maxWork);
}

//-- (ge)evx [real variant] ----------------------------------------------------

template <typename MA, typename VWR, typename VWI, typename MVL, typename MVR,
          typename IndexType, typename VSCALE, typename ABNORM,
          typename RCONDE, typename RCONDV, typename VWORK, typename VIWORK>
typename GeMatrix<MA>::IndexType
evx_impl(BALANCE::Balance     balance,
         bool                 computeVL,
         bool                 computeVR,
         SENSE::Sense         sense,
         GeMatrix<MA>         &A,
         DenseVector<VWR>     &wr,
         DenseVector<VWI>     &wi,
         GeMatrix<MVL>        &VL,
         GeMatrix<MVR>        &VR,
         IndexType            &iLo,
         IndexType            &iHi,
         DenseVector<VSCALE>  &scale,
         ABNORM               &ABNorm,
         DenseVector<RCONDE>  &rCondE,
         DenseVector<RCONDV>  &rCondV,
         DenseVector<VWORK>   &work,
         DenseVector<VIWORK>  &iWork)
{
    using flens::pow;

    typedef typename GeMatrix<MA>::ElementType   T;

    const IndexType             n = A.numRows();
    const Underscore<IndexType> _;

    const T   Zero(0), One(1);
//
//  .. Local Arrays ..
//
    bool _selectData[1];
    DenseVectorView<bool>
        select = typename DenseVectorView<bool>::Engine(1, _selectData);
//
//  Test the input arguments
//
    IndexType info = 0;

    const bool wantSN = (sense==SENSE::None);
    const bool wantSV = (sense==SENSE::InvariantSubspaceOnly);
    const bool wantSB = (sense==SENSE::Both);
//
//  Compute workspace
//   (Note: Comments in the code beginning "Workspace:" describe the
//    minimal amount of workspace needed at that point in the code,
//    as well as the preferred amount for good performance.
//    NB refers to the optimal block size for the immediately
//    following subroutine, as returned by ILAENV.
//    HSWORK refers to the workspace preferred by DHSEQR, as
//    calculated below. HSWORK is computed assuming ILO=1 and IHI=N,
//    the worst case.)
//
    Pair<IndexType> wsQuery = evx_wsq(computeVL, computeVR, sense, A);
    IndexType minWork = wsQuery.first;
    IndexType maxWork = wsQuery.second;

    if (work.length()!=0 && work.length()<minWork) {
        ASSERT(0);
    } else if (work.length()==0) {
        work.resize(maxWork);
    }
    work(1) = maxWork;

//
//  Quick return if possible
//
    if (n==0) {
        return info;
    }
//
//  Get machine constants
//
    const T eps = lamch<T>(Precision);
    T smallNum = lamch<T>(SafeMin);
    T bigNum = One / smallNum;
    labad(smallNum, bigNum);
    smallNum = sqrt(smallNum) / eps;
    bigNum = One / smallNum;
//
//  Scale A if max element outside range [SMLNUM,BIGNUM]
//
    IndexType iCond = 0;
    const T ANorm = lan(MaximumNorm, A);
    bool scaleA = false;
    T cScale;
    if (ANorm>Zero && ANorm<smallNum) {
        scaleAtrue;
        cScale = smallNum;
    } else if (ANorm>bigNum) {
        scaleAtrue;
        cScale = bigNum;
    }
    if (scaleA) {
        lascl(LASCL::FullMatrix, IndexType(0), IndexType(0), ANorm, cScale, A);
    }
//
//  Balance the matrix and compute ABNRM
//
    bal(balance, A, iLo, iHi, scale);
    ABNorm = lan(OneNorm, A);
    if (scaleA) {
        lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
              cScale, ANorm, ABNorm);
    }
//
//  Reduce to upper Hessenberg form
//  (Workspace: need 2*N, prefer N+N*NB)
//
    IndexType iTau = 1;
    IndexType iWrk = iTau + n;
    IndexType lWork = work.length();

    auto tau = work(_(iTau, iTau+n-2));
    auto hrdWork = work(_(iWrk, lWork));

    hrd(iLo, iHi, A, tau, hrdWork);

    if (computeVL) {
//
//      Want left eigenvectors
//      Copy Householder vectors to VL
//
        VL.lower() = A.lower();
//
//      Generate orthogonal matrix in VL
//      (Workspace: need 2*N-1, prefer N+(N-1)*NB)
//
        orghr(iLo, iHi, VL, tau, hrdWork);
//
//      Perform QR iteration, accumulating Schur vectors in VL
//      (Workspace: need 1, prefer HSWORK (see comments) )
//
        iWrk = iTau;
        auto hseqrWork = work(_(iWrk, lWork));
        info = hseqr(HSEQR::Schur, HSEQR::NoInit, iLo, iHi, A,
                     wr, wi, VL, hseqrWork);

        if (computeVR) {
//
//          Want left and right eigenvectors
//          Copy Schur vectors to VR
//
            VR = VL;
        }

    } else if (computeVR) {
//
//      Want right eigenvectors
//      Copy Householder vectors to VR
//
        VR.lower() = A.lower();
//
//      Generate orthogonal matrix in VR
//      (Workspace: need 2*N-1, prefer N+(N-1)*NB)
//
        orghr(iLo, iHi, VR, tau, hrdWork);
//
//      Perform QR iteration, accumulating Schur vectors in VR
//      (Workspace: need 1, prefer HSWORK (see comments) )
//
        iWrk = iTau;
        auto hseqrWork = work(_(iWrk, lWork));
        info = hseqr(HSEQR::Schur, HSEQR::NoInit, iLo, iHi, A,
                     wr, wi, VR, hseqrWork);

    } else {
//
//      Compute eigenvalues only
//      If condition numbers desired, compute Schur form
//
        HSEQR::Job  job = (wantSN) ? HSEQR::Eigenvalues
                                   : HSEQR::Schur;
//
//      (Workspace: need 1, prefer HSWORK (see comments) )
//
        iWrk = iTau;
        auto hseqrWork = work(_(iWrk, lWork));
        info = hseqr(job, HSEQR::No, iLo, iHi, A, wr, wi, VR, hseqrWork);
    }
//
//  If INFO > 0 from DHSEQR, then quit
//
    if (info==0) {

        if (computeVL || computeVR) {
//
//          Compute left and/or right eigenvectors
//          (Workspace: need 3*N)
//
            IndexType nOut;
            auto      trevcWork = work(_(iWrk, lWork));

            trevc(computeVL, computeVR, TREVC::Backtransform, select,
                  A, VL, VR, n, nOut, trevcWork);
        }
//
//      Compute condition numbers if desired
//      (Workspace: need N*N+6*N unless SENSE = 'E')
//
        if (!wantSN) {
            IndexType nOut;

            IndexType _n = (sense!=SENSE::EigenvaluesOnly) ? n0;
            GeMatrixView<T>  Work(_n, n+6, work(_(iWrk, lWork)), n);

            trsna(TRSNA::Job(sense), TRSNA::All, select, A, VL, VR,
                  rCondE, rCondV, n, nOut, Work, iWork);
        }

        if (computeVL) {
//
//          Undo balancing of left eigenvectors
//
            bak(balance, Left, iLo, iHi, scale, VL);
//
//          Normalize left eigenvectors and make largest component real
//
            for (IndexType i=1; i<=n; ++i) {
                if (wi(i)==Zero) {
                    VL(_,i) *= One / blas::nrm2(VL(_,i));
                } else if (wi(i)>Zero) {
                    const T scl = One / lapy2(blas::nrm2(VL(_,i)),
                                              blas::nrm2(VL(_,i+1)));
                    VL(_,i)     *= scl;
                    VL(_,i+1)   *= scl;
                    for (IndexType k=1; k<=n; ++k) {
                        work(k) = pow(VL(k,i),2) + pow(VL(k,i+1),2);
                    }
                    IndexType k = blas::iamax(work(_(1,n)));
                    T cs, sn, r;
                    lartg(VL(k,i), VL(k,i+1), cs, sn, r);
                    blas::rot(VL(_,i), VL(_,i+1), cs, sn);
                    VL(k,i+1) = Zero;
                }
            }
        }

        if (computeVR) {
//
//          Undo balancing of right eigenvectors
//
            bak(BALANCE::Both, Right, iLo, iHi, scale, VR);
//
//          Normalize right eigenvectors and make largest component real
//
            for (IndexType i=1; i<=n; ++i) {
                if (wi(i)==Zero) {
                    VR(_,i) *= One / blas::nrm2(VR(_,i));
                } else if (wi(i)>Zero) {
                    const T scl = One / lapy2(blas::nrm2(VR(_,i)),
                                              blas::nrm2(VR(_,i+1)));
                    VR(_,i)     *= scl;
                    VR(_,i+1)   *= scl;
                    for (IndexType k=1; k<=n; ++k) {
                        work(k) = pow(VR(k,i), 2) + pow(VR(k,i+1), 2);
                    }
                    IndexType k = blas::iamax(work(_(1,n)));
                    T cs, sn, r;
                    lartg(VR(k,i), VR(k,i+1), cs, sn, r);
                    blas::rot(VR(_,i), VR(_,i+1), cs, sn);
                    VR(k,i+1) = Zero;
                }
            }
        }
    }

//
//  Undo scaling if necessary
//
    if (scaleA) {
        lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
              cScale, ANorm, wr(_(info+1,n)));
        lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
              cScale, ANorm, wi(_(info+1,n)));

        if (info==0) {
            if ((wantSV || wantSB) && iCond==0) {
                lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
                      cScale, ANorm, rCondV);
            }
        } else {
            lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
                  cScale, ANorm, wr(_(1,iLo-1)));
            lascl(LASCL::FullMatrix, IndexType(0), IndexType(0),
                  cScale, ANorm, wi(_(1,iLo-1)));
        }
    }

    work(1) = maxWork;
    return info;
}

// namespace generic

//== interface for native lapack ===============================================

#ifdef USE_CXXLAPACK

namespace external {

//-- (ge)evx_wsq [worksize query, real variant] --------------------------------

template <typename MA>
typename RestrictTo<IsNotComplex<typename MA::ElementType>::value,
         Pair<typename MA::IndexType> >::Type
evx_wsq_impl(bool               computeVL,
             bool               computeVR,
             SENSE::Sense       sense,
             const GeMatrix<MA> &A)
{
    using std::max;

    typedef typename GeMatrix<MA>::ElementType  T;
    typedef typename GeMatrix<MA>::IndexType    IndexType;

    const bool wantSN = (sense==SENSE::None);
    const bool wantSE = (sense==SENSE::EigenvaluesOnly);

//
//  Compute minimal worksize
//
    IndexType  n = A.numRows();
    IndexType  minWork;

    if (n==0) {
        minWork1;
    } else {
        if ((!computeVL) && (!computeVR)) {
            minWork2*n;
            if (!wantSN) {
                minWork = max(minWork, n*n+6*n);
            }
        } else {
            minWork3*n;
            if ((!wantSN) && (!wantSE)) {
                minWork = max(minWork, n*n6*n);
            }
        }
    }

//
//  Compute optimal worksize
//
    const IndexType     LDVL   = A.numRows();
    const IndexType     LDVR   = A.numRows();
    IndexType           IDUMMY;
    T                   DUMMY;
    const IndexType     LWORK  = -1;
    T                   WORK;

    cxxlapack::geevx<IndexType>('N',
                                computeVL'V' : 'N',
                                computeVR'V' : 'N',
                                getF77Char(sense),
                                A.numRows(),
                                &DUMMY,
                                A.leadingDimension(),
                                &DUMMY,
                                &DUMMY,
                                &DUMMY,
                                LDVL,
                                &DUMMY,
                                LDVR,
                                IDUMMY,
                                IDUMMY,
                                &DUMMY,
                                DUMMY,
                                &DUMMY,
                                &DUMMY,
                                &WORK,
                                LWORK,
                                &IDUMMY);
    return Pair<IndexType>(minWork, WORK);
}

//-- (ge)evx_wsq [worksize query, complex variant] -----------------------------

template <typename MA>
typename RestrictTo<IsComplex<typename MA::ElementType>::value,
         Pair<typename MA::IndexType> >::Type
evx_wsq_impl(bool               computeVL,
             bool               computeVR,
             SENSE::Sense       sense,
             const GeMatrix<MA> &A)
{
    using std::max;

    typedef typename GeMatrix<MA>::ElementType          T;
    typedef typename ComplexTrait<T>::PrimitiveType     RT;
    typedef typename GeMatrix<MA>::IndexType            IndexType;

    const bool wantSN = (sense==SENSE::None);
    const bool wantSE = (sense==SENSE::EigenvaluesOnly);

//
//  Compute minimal worksize
//
    IndexType  n = A.numRows();
    IndexType  minWork;

    if (n==0) {
        minWork1;
    } else {
        minWork2*n;
        if (!wantSN && !wantSE) {
            minWork = max(minWork, n*n+2*n);
        }
    }

//
//  Compute optimal worksize
//
    const IndexType     LDVL   = A.numRows();
    const IndexType     LDVR   = A.numRows();
    IndexType           IDUMMY;
    T                   DUMMY;
    RT                  RDUMMY;
    const IndexType     LWORK  = -1;
    T                   WORK;

    cxxlapack::geevx<IndexType>('N',
                                computeVL'V' : 'N',
                                computeVR'V' : 'N',
                                getF77Char(sense),
                                A.numRows(),
                                &DUMMY,
                                A.leadingDimension(),
                                &DUMMY,                     // w
                                &DUMMY,                     // VL
                                LDVL,                       // ldVL
                                &DUMMY,                     // VR
                                LDVR,                       // ldVR
                                IDUMMY,                     // iLo
                                IDUMMY,                     // iHi
                                &RDUMMY,                    // scale
                                RDUMMY,                     // ABnorm
                                &RDUMMY,                    // rCondE
                                &RDUMMY,                    // rCondV
                                &WORK,                      // work
                                LWORK,                      // lWork
                                &RDUMMY);                   // rWork
    return Pair<IndexType>(minWork, WORK.real());
}

//-- (ge)evx [real variant] ----------------------------------------------------

template <typename MA, typename VWR, typename VWI, typename MVL, typename MVR,
          typename IndexType, typename VSCALE, typename ABNORM,
          typename RCONDE, typename RCONDV, typename VWORK, typename VIWORK>
typename GeMatrix<MA>::IndexType
evx_impl(BALANCE::Balance     balance,
         bool                 computeVL,
         bool                 computeVR,
         SENSE::Sense         sense,
         GeMatrix<MA>         &A,
         DenseVector<VWR>     &wr,
         DenseVector<VWI>     &wi,
         GeMatrix<MVL>        &VL,
         GeMatrix<MVR>        &VR,
         IndexType            &iLo,
         IndexType            &iHi,
         DenseVector<VSCALE>  &scale,
         ABNORM               &abNorm,
         DenseVector<RCONDE>  &rCondE,
         DenseVector<RCONDV>  &rCondV,
         DenseVector<VWORK>   &work,
         DenseVector<VIWORK>  &iWork)
{
    if (work.length()==0) {
        const auto ws = evx_wsq_impl(computeVL, computeVR, sense, A);
        work.resize(ws.second, 1);
    }

    IndexType  info;
    info = cxxlapack::geevx<IndexType>(getF77Char(balance),
                                       computeVL'V' : 'N',
                                       computeVR'V' : 'N',
                                       getF77Char(sense),
                                       A.numRows(),
                                       A.data(),
                                       A.leadingDimension(),
                                       wr.data(),
                                       wi.data(),
                                       VL.data(),
                                       VL.leadingDimension(),
                                       VR.data(),
                                       VR.leadingDimension(),
                                       iLo,
                                       iHi,
                                       scale.data(),
                                       abNorm,
                                       rCondE.data(),
                                       rCondV.data(),
                                       work.data(),
                                       work.length(),
                                       iWork.data());
    ASSERT(info>=0);
    return info;
}

//-- (ge)evx [complex variant] ----------------------------------------------------

template <typename MA, typename VW, typename MVL, typename MVR,
          typename IndexType, typename VSCALE, typename ABNORM,
          typename RCONDE, typename RCONDV, typename VWORK, typename VRWORK>
typename GeMatrix<MA>::IndexType
evx_impl(BALANCE::Balance     balance,
         bool                 computeVL,
         bool                 computeVR,
         SENSE::Sense         sense,
         GeMatrix<MA>         &A,
         DenseVector<VW>      &w,
         GeMatrix<MVL>        &VL,
         GeMatrix<MVR>        &VR,
         IndexType            &iLo,
         IndexType            &iHi,
         DenseVector<VSCALE>  &scale,
         ABNORM               &abNorm,
         DenseVector<RCONDE>  &rCondE,
         DenseVector<RCONDV>  &rCondV,
         DenseVector<VWORK>   &work,
         DenseVector<VRWORK>  &rWork)
{
    if (work.length()==0) {
        const auto ws = evx_wsq_impl(computeVL, computeVR, sense, A);
        work.resize(ws.second, 1);
    }

    IndexType  info;
    info = cxxlapack::geevx<IndexType>(getF77Char(balance),
                                       computeVL'V' : 'N',
                                       computeVR'V' : 'N',
                                       getF77Char(sense),
                                       A.numRows(),
                                       A.data(),
                                       A.leadingDimension(),
                                       w.data(),
                                       VL.data(),
                                       VL.leadingDimension(),
                                       VR.data(),
                                       VR.leadingDimension(),
                                       iLo,
                                       iHi,
                                       scale.data(),
                                       abNorm,
                                       rCondE.data(),
                                       rCondV.data(),
                                       work.data(),
                                       work.length(),
                                       rWork.data());
    ASSERT(info>=0);
    return info;
}

// namespace external

#endif // USE_CXXLAPACK

//== public interface ==========================================================

//-- (ge)evx [real variant] ----------------------------------------------------

template <typename MA, typename VWR, typename VWI, typename MVL, typename MVR,
          typename IndexType, typename VSCALE, typename ABNORM,
          typename VRCONDE, typename VRCONDV, typename VWORK, typename VIWORK>
typename RestrictTo<IsRealGeMatrix<MA>::value
                 && IsRealDenseVector<VWR>::value
                 && IsRealDenseVector<VWI>::value
                 && IsRealGeMatrix<MVL>::value
                 && IsRealGeMatrix<MVR>::value
                 && IsInteger<IndexType>::value
                 && IsRealDenseVector<VSCALE>::value
                 && IsNotComplex<ABNORM>::value
                 && IsRealDenseVector<VRCONDE>::value
                 && IsRealDenseVector<VRCONDV>::value
                 && IsRealDenseVector<VWORK>::value
                 && IsIntegerDenseVector<VIWORK>::value,
         IndexType>::Type
evx(BALANCE::Balance     balance,
    bool                 computeVL,
    bool                 computeVR,
    SENSE::Sense         sense,
    MA                   &&A,
    VWR                  &&wr,
    VWI                  &&wi,
    MVL                  &&VL,
    MVR                  &&VR,
    IndexType            &iLo,
    IndexType            &iHi,
    VSCALE               &&scale,
    ABNORM               &abNorm,
    VRCONDE              &&rCondE,
    VRCONDV              &&rCondV,
    VWORK                &&work,
    VIWORK               &&iWork)
{
    LAPACK_DEBUG_OUT("(ge)evx [real]");

//
//  Remove references from rvalue types
//
    typedef typename RemoveRef<MA>::Type        MatrixA;
    typedef typename RemoveRef<VWR>::Type       VectorWR;
    typedef typename RemoveRef<VWI>::Type       VectorWI;
    typedef typename RemoveRef<MVL>::Type       MatrixVL;
    typedef typename RemoveRef<MVR>::Type       MatrixVR;
    typedef typename RemoveRef<VSCALE>::Type    VectorScale;
    typedef typename RemoveRef<VRCONDE>::Type   VectorRCondE;
    typedef typename RemoveRef<VRCONDV>::Type   VectorRCondV;
    typedef typename RemoveRef<VWORK>::Type     VectorWork;
    typedef typename RemoveRef<VIWORK>::Type    VectorIWork;

    const IndexType n = A.numRows();

//
//  Test the input parameters
//
#   ifndef NDEBUG
    ASSERT(A.numRows()==A.numCols());
    ASSERT(A.firstRow()==1);
    ASSERT(A.firstCol()==1);
    ASSERT(work.firstIndex()==1);

    ASSERT(wr.firstIndex()==1);
    ASSERT(wr.length()==0 || wr.length()==n);

    ASSERT(wi.firstIndex()==1);
    ASSERT(wi.length()==0 || wi.length()==n);

    if (computeVL) {
        ASSERT(VL.numRows()==VL.numCols());
        ASSERT(VL.numRows()==0 || VL.numRows()==n);
        ASSERT(VL.firstRow()==1);
        ASSERT(VL.firstCol()==1);
    }

    if (computeVR) {
        ASSERT(VR.numRows()==VR.numCols());
        ASSERT(VR.numRows()==0 || VR.numRows()==n);
        ASSERT(VR.firstRow()==1);
        ASSERT(VR.firstCol()==1);
    }

    ASSERT(scale.firstIndex()==1);
    ASSERT(scale.length()==0 || scale.length()==n);

    ASSERT(rCondE.firstIndex()==1);
    ASSERT(rCondE.length()==0 || rCondE.length()==n);

    ASSERT(rCondV.firstIndex()==1);
    ASSERT(rCondV.length()==0 || rCondV.length()==n);

    ASSERT(iWork.length()==0 || iWork.length()==2*(n-1));
#   endif

//
//  Resize output arguments if they are empty and needed
//
    if (wr.length()==0) {
        wr.resize(n1);
    }
    if (wi.length()==0) {
        wi.resize(n1);
    }
    if (computeVL && VL.numRows()==0) {
        VL.resize(n, n11);
    }
    if (computeVR && VR.numRows()==0) {
        VR.resize(n, n11);
    }
    if (scale.length()==0) {
        scale.resize(n1);
    }
    if (rCondE.length()==0) {
        rCondE.resize(n1);
    }
    if (rCondV.length()==0) {
        rCondV.resize(n1);
    }
    if (iWork.length()==0) {
        iWork.resize(2*(n-1), 1);
    }
//
//  Make copies of output arguments
//
#   ifdef CHECK_CXXLAPACK
    typename MatrixA::NoView        A_org       = A;
    typename VectorWR::NoView       wr_org      = wr;
    typename VectorWI::NoView       wi_org      = wi;
    typename MatrixVL::NoView       VL_org      = VL;
    typename MatrixVR::NoView       VR_org      = VR;
    IndexType                       iLo_org     = iLo;
    IndexType                       iHi_org     = iHi;
    typename VectorScale::NoView    scale_org   = scale;
    ABNORM                          abNorm_org  = abNorm;
    typename VectorRCondE::NoView   rCondE_org  = rCondE;
    typename VectorRCondV::NoView   rCondV_org  = rCondV;
    typename VectorWork::NoView     work_org    = work;
    typename VectorIWork::NoView    iWork_org   = iWork;
#   endif

//
//  Call implementation
//
    IndexType info = LAPACK_SELECT::evx_impl(balance, computeVL, computeVR,
                                             sense, A, wr, wi, VL, VR,
                                             iLo, iHi, scale, abNorm,
                                             rCondE, rCondV, work, iWork);
#   ifdef CHECK_CXXLAPACK
//
//  Make copies of results computed by the generic implementation
//
    typename MatrixA::NoView        A_generic       = A;
    typename VectorWR::NoView       wr_generic      = wr;
    typename VectorWI::NoView       wi_generic      = wi;
    typename MatrixVL::NoView       VL_generic      = VL;
    typename MatrixVR::NoView       VR_generic      = VR;
    IndexType                       iLo_generic     = iLo;
    IndexType                       iHi_generic     = iHi;
    typename VectorScale::NoView    scale_generic   = scale;
    ABNORM                          abNorm_generic  = abNorm;
    typename VectorRCondE::NoView   rCondE_generic  = rCondE;
    typename VectorRCondV::NoView   rCondV_generic  = rCondV;
    typename VectorWork::NoView     work_generic    = work;
    typename VectorIWork::NoView    iWork_generic   = iWork;
//
//  restore output arguments
//
    A       = A_org;
    wr      = wr_org;
    wi      = wi_org;
    VL      = VL_org;
    VR      = VR_org;
    iLo     = iLo_org;
    iHi     = iHi_org;
    scale   = scale_org;
    abNorm  = abNorm_org;
    rCondE  = rCondE_org;
    rCondV  = rCondV_org;
    work    = work_org;
    iWork   = iWork_org;
//
//  Compare generic results with results from the native implementation
//
    IndexType _info = external::evx_impl(balance, computeVL, computeVR,
                                         sense, A, wr, wi, VL, VR, iLo, iHi,
                                         scale, abNorm, rCondE, rCondV,
                                         work, iWork);

    bool failed = false;
    if (! isIdentical(A_generic, A, "A_generic""A")) {
        std::cerr << "CXXLAPACK: A_generic = " << A_generic << std::endl;
        std::cerr << "F77LAPACK: A = " << A << std::endl;
        failed = true;
    }

    if (! isIdentical(wr_generic, wr, "wr_generic""wr")) {
        std::cerr << "CXXLAPACK: wr_generic = " << wr_generic << std::endl;
        std::cerr << "F77LAPACK: wr = " << wr << std::endl;
        failed = true;
    }

    if (! isIdentical(wi_generic, wi, "wi_generic""wi")) {
        std::cerr << "CXXLAPACK: wi_generic = " << wi_generic << std::endl;
        std::cerr << "F77LAPACK: wi = " << wi << std::endl;
        failed = true;
    }

    if (! isIdentical(VL_generic, VL, "VL_generic""VL")) {
        std::cerr << "CXXLAPACK: VL_generic = " << VL_generic << std::endl;
        std::cerr << "F77LAPACK: VL = " << VL << std::endl;
        failed = true;
    }

    if (! isIdentical(VR_generic, VR, "VR_generic""VR")) {
        std::cerr << "CXXLAPACK: VR_generic = " << VR_generic << std::endl;
        std::cerr << "F77LAPACK: VR = " << VR << std::endl;
        failed = true;
    }

    if (! isIdentical(iLo_generic, iLo, "iLo_generic""iLo")) {
        std::cerr << "CXXLAPACK: iLo_generic = " << iLo_generic << std::endl;
        std::cerr << "F77LAPACK: iLo = " << iLo << std::endl;
        failed = true;
    }

    if (! isIdentical(iHi_generic, iHi, "iHi_generic""iHi")) {
        std::cerr << "CXXLAPACK: iHi_generic = " << iHi_generic << std::endl;
        std::cerr << "F77LAPACK: iHi = " << iHi << std::endl;
        failed = true;
    }

    if (! isIdentical(scale_generic, scale, "scale_generic""scale")) {
        std::cerr << "CXXLAPACK: scale_generic = "
                  << scale_generic << std::endl;
        std::cerr << "F77LAPACK: scale = " << scale << std::endl;
        failed = true;
    }

    if (! isIdentical(abNorm_generic, abNorm, "abNorm_generic""abNorm")) {
        std::cerr << "CXXLAPACK: abNorm_generic = "
                  << abNorm_generic << std::endl;
        std::cerr << "F77LAPACK: abNorm = " << abNorm << std::endl;
        failed = true;
    }

    if (! isIdentical(rCondE_generic, rCondE, "rCondE_generic""rCondE")) {
        std::cerr << "CXXLAPACK: rCondE_generic = "
                  << rCondE_generic << std::endl;
        std::cerr << "F77LAPACK: rCondE = " << rCondE << std::endl;
        failed = true;
    }

    if (! isIdentical(rCondV_generic, rCondV, "rCondV_generic""rCondV")) {
        std::cerr << "CXXLAPACK: rCondV_generic = "
                  << rCondV_generic << std::endl;
        std::cerr << "F77LAPACK: rCondV = " << rCondV << std::endl;
        failed = true;
    }

    if (! isIdentical(work_generic, work, "work_generic""work")) {
        std::cerr << "CXXLAPACK: work_generic = " << work_generic << std::endl;
        std::cerr << "F77LAPACK: work = " << work << std::endl;
        failed = true;
    }

    if (! isIdentical(iWork_generic, iWork, "iWork_generic""iWork")) {
        std::cerr << "CXXLAPACK: iWork_generic = "
                  << iWork_generic << std::endl;
        std::cerr << "F77LAPACK: iWork = " << iWork << std::endl;
        failed = true;
    }

    if (! isIdentical(info, _info, " info""_info")) {
        std::cerr << "CXXLAPACK:  info = " << info << std::endl;
        std::cerr << "F77LAPACK: _info = " << _info << std::endl;
        failed = true;
    }

    if (failed) {
        ASSERT(0);
    } else {
//        std::cerr << "passed: evx.tcc" << std::endl;
    }
#   endif

    return info;
}


#ifdef USE_CXXLAPACK

//-- (ge)evx [complex variant] ----------------------------------------------------

template <typename MA, typename VW, typename MVL, typename MVR,
          typename IndexType, typename VSCALE, typename ABNORM,
          typename VRCONDE, typename VRCONDV, typename VWORK, typename VRWORK>
typename RestrictTo<IsComplexGeMatrix<MA>::value
                 && IsComplexDenseVector<VW>::value
                 && IsComplexGeMatrix<MVL>::value
                 && IsComplexGeMatrix<MVR>::value
                 && IsInteger<IndexType>::value
                 && IsRealDenseVector<VSCALE>::value
                 && IsNotComplex<ABNORM>::value
                 && IsRealDenseVector<VRCONDE>::value
                 && IsRealDenseVector<VRCONDV>::value
                 && IsComplexDenseVector<VWORK>::value
                 && IsRealDenseVector<VRWORK>::value,
         IndexType>::Type
evx(BALANCE::Balance     balance,
    bool                 computeVL,
    bool                 computeVR,
    SENSE::Sense         sense,
    MA                   &&A,
    VW                   &&w,
    MVL                  &&VL,
    MVR                  &&VR,
    IndexType            &iLo,
    IndexType            &iHi,
    VSCALE               &&scale,
    ABNORM               &abNorm,
    VRCONDE              &&rCondE,
    VRCONDV              &&rCondV,
    VWORK                &&work,
    VRWORK               &&rWork)
{
    LAPACK_DEBUG_OUT("(ge)evx [complex]");

//
//  Remove references from rvalue types
//
    typedef typename RemoveRef<MA>::Type        MatrixA;
    typedef typename RemoveRef<VW>::Type        VectorW;
    typedef typename RemoveRef<MVL>::Type       MatrixVL;
    typedef typename RemoveRef<MVR>::Type       MatrixVR;
    typedef typename RemoveRef<VSCALE>::Type    VectorScale;
    typedef typename RemoveRef<VRCONDE>::Type   VectorRCondE;
    typedef typename RemoveRef<VRCONDV>::Type   VectorRCondV;
    typedef typename RemoveRef<VWORK>::Type     VectorWork;
    typedef typename RemoveRef<VRWORK>::Type    VectorRWork;

    const IndexType n = A.numRows();

//
//  Test the input parameters
//
#   ifndef NDEBUG
    ASSERT(A.numRows()==A.numCols());
    ASSERT(A.firstRow()==1);
    ASSERT(A.firstCol()==1);
    ASSERT(work.firstIndex()==1);

    ASSERT(w.firstIndex()==1);
    ASSERT(w.length()==0 || w.length()==n);

    if (computeVL) {
        ASSERT(VL.numRows()==VL.numCols());
        ASSERT(VL.numRows()==0 || VL.numRows()==n);
        ASSERT(VL.firstRow()==1);
        ASSERT(VL.firstCol()==1);
    }

    if (computeVR) {
        ASSERT(VR.numRows()==VR.numCols());
        ASSERT(VR.numRows()==0 || VR.numRows()==n);
        ASSERT(VR.firstRow()==1);
        ASSERT(VR.firstCol()==1);
    }

    ASSERT(scale.firstIndex()==1);
    ASSERT(scale.length()==0 || scale.length()==n);

    ASSERT(rCondE.firstIndex()==1);
    ASSERT(rCondE.length()==0 || rCondE.length()==n);

    ASSERT(rCondV.firstIndex()==1);
    ASSERT(rCondV.length()==0 || rCondV.length()==n);

    ASSERT(rWork.length()==0 || rWork.length()==2*n);
#   endif

//
//  Resize output arguments if they are empty (and needed).
//
    if (w.length()==0) {
        w.resize(n1);
    }
    if (computeVL && VL.numRows()==0) {
        VL.resize(n, n11);
    }
    if (computeVR && VR.numRows()==0) {
        VR.resize(n, n11);
    }
    if (scale.length()==0) {
        scale.resize(n1);
    }
    if (rCondE.length()==0) {
        rCondE.resize(n1);
    }
    if (rCondV.length()==0) {
        rCondV.resize(n1);
    }
    if (rWork.length()==0) {
        rWork.resize(2*n1);
    }

//
//  Call external implementation
//
    IndexType info = external::evx_impl(balance, computeVL, computeVR,
                                        sense, A, w, VL, VR,
                                        iLo, iHi, scale, abNorm,
                                        rCondE, rCondV, work, rWork);
    return info;
}

#endif // USE_CXXLAPACK

//-- (ge)evx_wsq [worksize query, real variant] --------------------------------

template <typename MA>
typename RestrictTo<IsRealGeMatrix<MA>::value,
         Pair<typename MA::IndexType> >::Type
evx_wsq(bool computeVL, bool computeVR, SENSE::Sense sense, const MA &A)
{
    return LAPACK_SELECT::evx_wsq_impl(computeVL, computeVR, sense, A);
}

//-- (ge)evx_wsq [worksize query, complex variant] -----------------------------

#ifdef USE_CXXLAPACK

template <typename MA>
typename RestrictTo<IsComplexGeMatrix<MA>::value,
         Pair<typename MA::IndexType> >::Type
evx_wsq(bool computeVL, bool computeVR, SENSE::Sense sense, const MA &A)
{
    return external::evx_wsq_impl(computeVL, computeVR, sense, A);
}

#endif // USE_CXXLAPACK


} } // namespace lapack, flens

#endif // FLENS_LAPACK_GE_EVX_TCC