ZLAQR5(3)      LAPACK routine of NEC Numeric Library Collection      ZLAQR5(3)



NAME
       ZLAQR5

SYNOPSIS
       SUBROUTINE ZLAQR5 (WANTT, WANTZ, KACC22, N, KTOP, KBOT, NSHFTS, S, H,
           LDH, ILOZ, IHIZ, Z, LDZ, V, LDV, U, LDU, NV, WV, LDWV, NH, WH,
           LDWH)



PURPOSE
               ZLAQR5, called by ZLAQR0, performs a
               single small-bulge multi-shift QR sweep.




ARGUMENTS
           WANTT     (input)
                     WANTT is logical scalar
                        WANTT = .true. if the triangular Schur factor
                        is being computed.  WANTT is set to .false. otherwise.

           WANTZ     (input)
                     WANTZ is logical scalar
                        WANTZ = .true. if the unitary Schur factor is being
                        computed.  WANTZ is set to .false. otherwise.

           KACC22    (input)
                     KACC22 is integer with value 0, 1, or 2.
                        Specifies the computation mode of far-from-diagonal
                        orthogonal updates.
                   = 0: ZLAQR5 does not accumulate reflections and does not
                        use matrix-matrix multiply to update far-from-diagonal
                        matrix entries.
                   = 1: ZLAQR5 accumulates reflections and uses matrix-matrix
                        multiply to update the far-from-diagonal matrix entries.
                   = 2: ZLAQR5 accumulates reflections, uses matrix-matrix
                        multiply to update the far-from-diagonal matrix entries,
                        and takes advantage of 2-by-2 block structure during
                        matrix multiplies.

           N         (input)
                     N is integer scalar
                        N is the order of the Hessenberg matrix H upon which this
                        subroutine operates.

           KTOP      (input)
                     KTOP is integer scalar

           KBOT      (input)
                     KBOT is integer scalar
                        These are the first and last rows and columns of an
                        isolated diagonal block upon which the QR sweep is to be
                        applied. It is assumed without a check that
                                  either KTOP = 1  or   H(KTOP,KTOP-1) = 0
                        and
                                  either KBOT = N  or   H(KBOT+1,KBOT) = 0.

           NSHFTS    (input)
                     NSHFTS is integer scalar
                        NSHFTS gives the number of simultaneous shifts.  NSHFTS
                        must be positive and even.

           S         (input/output)
                     S is COMPLEX*16 array of size (NSHFTS)
                        S contains the shifts of origin that define the multi-
                        shift QR sweep.  On output S may be reordered.

           H         (input/output)
                     H is COMPLEX*16 array of size (LDH,N)
                        On input H contains a Hessenberg matrix.  On output a
                        multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied
                        to the isolated diagonal block in rows and columns KTOP
                        through KBOT.

           LDH       (input)
                     LDH is integer scalar
                        LDH is the leading dimension of H just as declared in the
                        calling procedure.  LDH.GE.MAX(1,N).

           ILOZ      (input)
                     ILOZ is INTEGER

           IHIZ      (input)
                     IHIZ is INTEGER
                        Specify the rows of Z to which transformations must be
                        applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N

           Z         (input/output)
                     Z is COMPLEX*16 array of size (LDZ,IHI)
                        If WANTZ = .TRUE., then the QR Sweep unitary
                        similarity transformation is accumulated into
                        Z(ILOZ:IHIZ,ILO:IHI) from the right.
                        If WANTZ = .FALSE., then Z is unreferenced.

           LDZ       (input)
                     LDZ is integer scalar
                        LDA is the leading dimension of Z just as declared in
                        the calling procedure. LDZ.GE.N.

           V         (output)
                     V is COMPLEX*16 array of size (LDV,NSHFTS/2)

           LDV       (input)
                     LDV is integer scalar
                        LDV is the leading dimension of V as declared in the
                        calling procedure.  LDV.GE.3.

           U         (output)
                     U is COMPLEX*16 array of size
                        (LDU,3*NSHFTS-3)

           LDU       (input)
                     LDU is integer scalar
                        LDU is the leading dimension of U just as declared in the
                        in the calling subroutine.  LDU.GE.3*NSHFTS-3.

           NH        (input)
                     NH is integer scalar
                        NH is the number of columns in array WH available for
                        workspace. NH.GE.1.

           WH        (output)
                     WH is COMPLEX*16 array of size (LDWH,NH)

           LDWH      (input)
                     LDWH is integer scalar
                        Leading dimension of WH just as declared in the
                        calling procedure.  LDWH.GE.3*NSHFTS-3.

           NV        (input)
                     NV is integer scalar
                        NV is the number of rows in WV agailable for workspace.
                        NV.GE.1.

           WV        (output)
                     WV is COMPLEX*16 array of size
                        (LDWV,3*NSHFTS-3)

           LDWV      (input)
                     LDWV is integer scalar
                        LDWV is the leading dimension of WV as declared in the
                        in the calling subroutine.  LDWV.GE.NV.



LAPACK routine                  31 October 2017                      ZLAQR5(3)