CGELQT computes a blocked LQ factorization of a complex M-by-N matrix A


 using the compact WY representation of Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

MB

          MB is INTEGER


          The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1.

A

          A is COMPLEX array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and below the diagonal of the array


          contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is


          lower triangular if M <= N); the elements above the diagonal


          are the rows of V.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is COMPLEX array, dimension (LDT,MIN(M,N))


          The upper triangular block reflectors stored in compact form


          as a sequence of upper triangular blocks.  See below


          for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

WORK

          WORK is COMPLEX array, dimension (MB*N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (         1 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.


  Let K=MIN(M,N).  The number of blocks is B = ceiling(K/MB), where each


  block is of order MB except for the last block, which is of order


  IB = K - (B-1)*MB.  For each of the B blocks, a upper triangular block


  reflector factor is computed: T1, T2, ..., TB.  The MB-by-MB (and IB-by-IB


  for the last block) T's are stored in the MB-by-K matrix T as


               T = (T1 T2 ... TB).

 CGELQT3 recursively computes a LQ factorization of a complex M-by-N


 matrix A, using the compact WY representation of Q.


 Based on the algorithm of Elmroth and Gustavson,


 IBM J. Res. Develop. Vol 44 No. 4 July 2000.

M

          M is INTEGER


          The number of rows of the matrix A.  M =< N.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is COMPLEX array, dimension (LDA,N)


          On entry, the complex M-by-N matrix A.  On exit, the elements on and


          below the diagonal contain the N-by-N lower triangular matrix L; the


          elements above the diagonal are the rows of V.  See below for


          further details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is COMPLEX array, dimension (LDT,N)


          The N-by-N upper triangular factor of the block reflector.


          The elements on and above the diagonal contain the block


          reflector T; the elements below the diagonal are not used.


          See below for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max(1,N).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (     1  v3 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The


  block reflector H is then given by


               H = I - V * T * V**T


  where V**T is the transpose of V.


  For details of the algorithm, see Elmroth and Gustavson (cited above).

 CGEMLQT overwrites the general complex M-by-N matrix C with


                 SIDE = 'L'     SIDE = 'R'


 TRANS = 'N':      Q C            C Q


 TRANS = 'C':   Q**H C            C Q**H


 where Q is a complex unitary matrix defined as the product of K


 elementary reflectors:


       Q = H(1) H(2) . . . H(K) = I - V T V**H


 generated using the compact WY representation as returned by CGELQT.


 Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'.

SIDE

          SIDE is CHARACTER*1


          = 'L': apply Q or Q**H from the Left;


          = 'R': apply Q or Q**H from the Right.

TRANS

          TRANS is CHARACTER*1


          = 'N':  No transpose, apply Q;


          = 'C':  Conjugate transpose, apply Q**H.

M

          M is INTEGER


          The number of rows of the matrix C. M >= 0.

N

          N is INTEGER


          The number of columns of the matrix C. N >= 0.

K

          K is INTEGER


          The number of elementary reflectors whose product defines


          the matrix Q.


          If SIDE = 'L', M >= K >= 0;


          if SIDE = 'R', N >= K >= 0.

MB

          MB is INTEGER


          The block size used for the storage of T.  K >= MB >= 1.


          This must be the same value of MB used to generate T


          in CGELQT.

V

          V is COMPLEX array, dimension


                               (LDV,M) if SIDE = 'L',


                               (LDV,N) if SIDE = 'R'


          The i-th row must contain the vector which defines the


          elementary reflector H(i), for i = 1,2,...,k, as returned by


          CGELQT in the first K rows of its array argument A.

LDV

          LDV is INTEGER


          The leading dimension of the array V. LDV >= max(1,K).

T

          T is COMPLEX array, dimension (LDT,K)


          The upper triangular factors of the block reflectors


          as returned by CGELQT, stored as a MB-by-K matrix.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

C

          C is COMPLEX array, dimension (LDC,N)


          On entry, the M-by-N matrix C.


          On exit, C is overwritten by Q C, Q**H C, C Q**H or C Q.

LDC

          LDC is INTEGER


          The leading dimension of the array C. LDC >= max(1,M).

WORK

          WORK is COMPLEX array. The dimension of


          WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEBAK forms the right or left eigenvectors of a real general matrix


 by backward transformation on the computed eigenvectors of the


 balanced matrix output by DGEBAL.

JOB

          JOB is CHARACTER*1


          Specifies the type of backward transformation required:


          = 'N': do nothing, return immediately;


          = 'P': do backward transformation for permutation only;


          = 'S': do backward transformation for scaling only;


          = 'B': do backward transformations for both permutation and


                 scaling.


          JOB must be the same as the argument JOB supplied to DGEBAL.

SIDE

          SIDE is CHARACTER*1


          = 'R':  V contains right eigenvectors;


          = 'L':  V contains left eigenvectors.

N

          N is INTEGER


          The number of rows of the matrix V.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          The integers ILO and IHI determined by DGEBAL.


          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

SCALE

          SCALE is DOUBLE PRECISION array, dimension (N)


          Details of the permutation and scaling factors, as returned


          by DGEBAL.

M

          M is INTEGER


          The number of columns of the matrix V.  M >= 0.

V

          V is DOUBLE PRECISION array, dimension (LDV,M)


          On entry, the matrix of right or left eigenvectors to be


          transformed, as returned by DHSEIN or DTREVC.


          On exit, V is overwritten by the transformed eigenvectors.

LDV

          LDV is INTEGER


          The leading dimension of the array V. LDV >= max(1,N).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEBAL balances a general real matrix A.  This involves, first,


 permuting A by a similarity transformation to isolate eigenvalues


 in the first 1 to ILO-1 and last IHI+1 to N elements on the


 diagonal; and second, applying a diagonal similarity transformation


 to rows and columns ILO to IHI to make the rows and columns as


 close in norm as possible.  Both steps are optional.


 Balancing may reduce the 1-norm of the matrix, and improve the


 accuracy of the computed eigenvalues and/or eigenvectors.

JOB

          JOB is CHARACTER*1


          Specifies the operations to be performed on A:


          = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0


                  for i = 1,...,N;


          = 'P':  permute only;


          = 'S':  scale only;


          = 'B':  both permute and scale.

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the input matrix A.


          On exit,  A is overwritten by the balanced matrix.


          If JOB = 'N', A is not referenced.


          See Further Details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI are set to integers such that on exit


          A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.


          If JOB = 'N' or 'S', ILO = 1 and IHI = N.

SCALE

          SCALE is DOUBLE PRECISION array, dimension (N)


          Details of the permutations and scaling factors applied to


          A.  If P(j) is the index of the row and column interchanged


          with row and column j and D(j) is the scaling factor


          applied to row and column j, then


          SCALE(j) = P(j)    for j = 1,...,ILO-1


                   = D(j)    for j = ILO,...,IHI


                   = P(j)    for j = IHI+1,...,N.


          The order in which the interchanges are made is N to IHI+1,


          then 1 to ILO-1.

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The permutations consist of row and column interchanges which put


  the matrix in the form


             ( T1   X   Y  )


     P A P = (  0   B   Z  )


             (  0   0   T2 )


  where T1 and T2 are upper triangular matrices whose eigenvalues lie


  along the diagonal.  The column indices ILO and IHI mark the starting


  and ending columns of the submatrix B. Balancing consists of applying


  a diagonal similarity transformation inv(D) * B * D to make the


  1-norms of each row of B and its corresponding column nearly equal.


  The output matrix is


     ( T1     X*D          Y    )


     (  0  inv(D)*B*D  inv(D)*Z ).


     (  0      0           T2   )


  Information about the permutations P and the diagonal matrix D is


  returned in the vector SCALE.


  This subroutine is based on the EISPACK routine BALANC.


  Modified by Tzu-Yi Chen, Computer Science Division, University of


    California at Berkeley, USA

 DGEBD2 reduces a real general m by n matrix A to upper or lower


 bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.


 If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

M

          M is INTEGER


          The number of rows in the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns in the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n general matrix to be reduced.


          On exit,


          if m >= n, the diagonal and the first superdiagonal are


            overwritten with the upper bidiagonal matrix B; the


            elements below the diagonal, with the array TAUQ, represent


            the orthogonal matrix Q as a product of elementary


            reflectors, and the elements above the first superdiagonal,


            with the array TAUP, represent the orthogonal matrix P as


            a product of elementary reflectors;


          if m < n, the diagonal and the first subdiagonal are


            overwritten with the lower bidiagonal matrix B; the


            elements below the first subdiagonal, with the array TAUQ,


            represent the orthogonal matrix Q as a product of


            elementary reflectors, and the elements above the diagonal,


            with the array TAUP, represent the orthogonal matrix P as


            a product of elementary reflectors.


          See Further Details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

D

          D is DOUBLE PRECISION array, dimension (min(M,N))


          The diagonal elements of the bidiagonal matrix B:


          D(i) = A(i,i).

E

          E is DOUBLE PRECISION array, dimension (min(M,N)-1)


          The off-diagonal elements of the bidiagonal matrix B:


          if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;


          if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1.

TAUQ

          TAUQ is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors which


          represent the orthogonal matrix Q. See Further Details.

TAUP

          TAUP is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors which


          represent the orthogonal matrix P. See Further Details.

WORK

          WORK is DOUBLE PRECISION array, dimension (max(M,N))

INFO

          INFO is INTEGER


          = 0: successful exit.


          < 0: if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrices Q and P are represented as products of elementary


  reflectors:


  If m >= n,


     Q = H(1) H(2) . . . H(n)  and  P = G(1) G(2) . . . G(n-1)


  Each H(i) and G(i) has the form:


     H(i) = I - tauq * v * v**T  and G(i) = I - taup * u * u**T


  where tauq and taup are real scalars, and v and u are real vectors;


  v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);


  u(1:i) = 0, u(i+1) = 1, and u(i+2:n) is stored on exit in A(i,i+2:n);


  tauq is stored in TAUQ(i) and taup in TAUP(i).


  If m < n,


     Q = H(1) H(2) . . . H(m-1)  and  P = G(1) G(2) . . . G(m)


  Each H(i) and G(i) has the form:


     H(i) = I - tauq * v * v**T  and G(i) = I - taup * u * u**T


  where tauq and taup are real scalars, and v and u are real vectors;


  v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);


  u(1:i-1) = 0, u(i) = 1, and u(i+1:n) is stored on exit in A(i,i+1:n);


  tauq is stored in TAUQ(i) and taup in TAUP(i).


  The contents of A on exit are illustrated by the following examples:


  m = 6 and n = 5 (m > n):          m = 5 and n = 6 (m < n):


    (  d   e   u1  u1  u1 )           (  d   u1  u1  u1  u1  u1 )


    (  v1  d   e   u2  u2 )           (  e   d   u2  u2  u2  u2 )


    (  v1  v2  d   e   u3 )           (  v1  e   d   u3  u3  u3 )


    (  v1  v2  v3  d   e  )           (  v1  v2  e   d   u4  u4 )


    (  v1  v2  v3  v4  d  )           (  v1  v2  v3  e   d   u5 )


    (  v1  v2  v3  v4  v5 )


  where d and e denote diagonal and off-diagonal elements of B, vi


  denotes an element of the vector defining H(i), and ui an element of


  the vector defining G(i).

 DGEBRD reduces a general real M-by-N matrix A to upper or lower


 bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.


 If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

M

          M is INTEGER


          The number of rows in the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns in the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N general matrix to be reduced.


          On exit,


          if m >= n, the diagonal and the first superdiagonal are


            overwritten with the upper bidiagonal matrix B; the


            elements below the diagonal, with the array TAUQ, represent


            the orthogonal matrix Q as a product of elementary


            reflectors, and the elements above the first superdiagonal,


            with the array TAUP, represent the orthogonal matrix P as


            a product of elementary reflectors;


          if m < n, the diagonal and the first subdiagonal are


            overwritten with the lower bidiagonal matrix B; the


            elements below the first subdiagonal, with the array TAUQ,


            represent the orthogonal matrix Q as a product of


            elementary reflectors, and the elements above the diagonal,


            with the array TAUP, represent the orthogonal matrix P as


            a product of elementary reflectors.


          See Further Details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

D

          D is DOUBLE PRECISION array, dimension (min(M,N))


          The diagonal elements of the bidiagonal matrix B:


          D(i) = A(i,i).

E

          E is DOUBLE PRECISION array, dimension (min(M,N)-1)


          The off-diagonal elements of the bidiagonal matrix B:


          if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;


          if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1.

TAUQ

          TAUQ is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors which


          represent the orthogonal matrix Q. See Further Details.

TAUP

          TAUP is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors which


          represent the orthogonal matrix P. See Further Details.

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The length of the array WORK.  LWORK >= max(1,M,N).


          For optimum performance LWORK >= (M+N)*NB, where NB


          is the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrices Q and P are represented as products of elementary


  reflectors:


  If m >= n,


     Q = H(1) H(2) . . . H(n)  and  P = G(1) G(2) . . . G(n-1)


  Each H(i) and G(i) has the form:


     H(i) = I - tauq * v * v**T  and G(i) = I - taup * u * u**T


  where tauq and taup are real scalars, and v and u are real vectors;


  v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);


  u(1:i) = 0, u(i+1) = 1, and u(i+2:n) is stored on exit in A(i,i+2:n);


  tauq is stored in TAUQ(i) and taup in TAUP(i).


  If m < n,


     Q = H(1) H(2) . . . H(m-1)  and  P = G(1) G(2) . . . G(m)


  Each H(i) and G(i) has the form:


     H(i) = I - tauq * v * v**T  and G(i) = I - taup * u * u**T


  where tauq and taup are real scalars, and v and u are real vectors;


  v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);


  u(1:i-1) = 0, u(i) = 1, and u(i+1:n) is stored on exit in A(i,i+1:n);


  tauq is stored in TAUQ(i) and taup in TAUP(i).


  The contents of A on exit are illustrated by the following examples:


  m = 6 and n = 5 (m > n):          m = 5 and n = 6 (m < n):


    (  d   e   u1  u1  u1 )           (  d   u1  u1  u1  u1  u1 )


    (  v1  d   e   u2  u2 )           (  e   d   u2  u2  u2  u2 )


    (  v1  v2  d   e   u3 )           (  v1  e   d   u3  u3  u3 )


    (  v1  v2  v3  d   e  )           (  v1  v2  e   d   u4  u4 )


    (  v1  v2  v3  v4  d  )           (  v1  v2  v3  e   d   u5 )


    (  v1  v2  v3  v4  v5 )


  where d and e denote diagonal and off-diagonal elements of B, vi


  denotes an element of the vector defining H(i), and ui an element of


  the vector defining G(i).

 DGECON estimates the reciprocal of the condition number of a general


 real matrix A, in either the 1-norm or the infinity-norm, using


 the LU factorization computed by DGETRF.


 An estimate is obtained for norm(inv(A)), and the reciprocal of the


 condition number is computed as


    RCOND = 1 / ( norm(A) * norm(inv(A)) ).

NORM

          NORM is CHARACTER*1


          Specifies whether the 1-norm condition number or the


          infinity-norm condition number is required:


          = '1' or 'O':  1-norm;


          = 'I':         Infinity-norm.

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          The factors L and U from the factorization A = P*L*U


          as computed by DGETRF.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

ANORM

          ANORM is DOUBLE PRECISION


          If NORM = '1' or 'O', the 1-norm of the original matrix A.


          If NORM = 'I', the infinity-norm of the original matrix A.

RCOND

          RCOND is DOUBLE PRECISION


          The reciprocal of the condition number of the matrix A,


          computed as RCOND = 1/(norm(A) * norm(inv(A))).

WORK

          WORK is DOUBLE PRECISION array, dimension (4*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEEQU computes row and column scalings intended to equilibrate an


 M-by-N matrix A and reduce its condition number.  R returns the row


 scale factors and C the column scale factors, chosen to try to make


 the largest element in each row and column of the matrix B with


 elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.


 R(i) and C(j) are restricted to be between SMLNUM = smallest safe


 number and BIGNUM = largest safe number.  Use of these scaling


 factors is not guaranteed to reduce the condition number of A but


 works well in practice.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          The M-by-N matrix whose equilibration factors are


          to be computed.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

R

          R is DOUBLE PRECISION array, dimension (M)


          If INFO = 0 or INFO > M, R contains the row scale factors


          for A.

C

          C is DOUBLE PRECISION array, dimension (N)


          If INFO = 0,  C contains the column scale factors for A.

ROWCND

          ROWCND is DOUBLE PRECISION


          If INFO = 0 or INFO > M, ROWCND contains the ratio of the


          smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and


          AMAX is neither too large nor too small, it is not worth


          scaling by R.

COLCND

          COLCND is DOUBLE PRECISION


          If INFO = 0, COLCND contains the ratio of the smallest


          C(i) to the largest C(i).  If COLCND >= 0.1, it is not


          worth scaling by C.

AMAX

          AMAX is DOUBLE PRECISION


          Absolute value of largest matrix element.  If AMAX is very


          close to overflow or very close to underflow, the matrix


          should be scaled.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i,  and i is


                <= M:  the i-th row of A is exactly zero


                >  M:  the (i-M)-th column of A is exactly zero

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEEQUB computes row and column scalings intended to equilibrate an


 M-by-N matrix A and reduce its condition number.  R returns the row


 scale factors and C the column scale factors, chosen to try to make


 the largest element in each row and column of the matrix B with


 elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most


 the radix.


 R(i) and C(j) are restricted to be a power of the radix between


 SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use


 of these scaling factors is not guaranteed to reduce the condition


 number of A but works well in practice.


 This routine differs from DGEEQU by restricting the scaling factors


 to a power of the radix.  Barring over- and underflow, scaling by


 these factors introduces no additional rounding errors.  However, the


 scaled entries' magnitudes are no longer approximately 1 but lie


 between sqrt(radix) and 1/sqrt(radix).

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          The M-by-N matrix whose equilibration factors are


          to be computed.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

R

          R is DOUBLE PRECISION array, dimension (M)


          If INFO = 0 or INFO > M, R contains the row scale factors


          for A.

C

          C is DOUBLE PRECISION array, dimension (N)


          If INFO = 0,  C contains the column scale factors for A.

ROWCND

          ROWCND is DOUBLE PRECISION


          If INFO = 0 or INFO > M, ROWCND contains the ratio of the


          smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and


          AMAX is neither too large nor too small, it is not worth


          scaling by R.

COLCND

          COLCND is DOUBLE PRECISION


          If INFO = 0, COLCND contains the ratio of the smallest


          C(i) to the largest C(i).  If COLCND >= 0.1, it is not


          worth scaling by C.

AMAX

          AMAX is DOUBLE PRECISION


          Absolute value of largest matrix element.  If AMAX is very


          close to overflow or very close to underflow, the matrix


          should be scaled.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i,  and i is


                <= M:  the i-th row of A is exactly zero


                >  M:  the (i-M)-th column of A is exactly zero

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEHD2 reduces a real general matrix A to upper Hessenberg form H by


 an orthogonal similarity transformation:  Q**T * A * Q = H .

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          It is assumed that A is already upper triangular in rows


          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally


          set by a previous call to DGEBAL; otherwise they should be


          set to 1 and N respectively. See Further Details.


          1 <= ILO <= IHI <= max(1,N).

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the n by n general matrix to be reduced.


          On exit, the upper triangle and the first subdiagonal of A


          are overwritten with the upper Hessenberg matrix H, and the


          elements below the first subdiagonal, with the array TAU,


          represent the orthogonal matrix Q as a product of elementary


          reflectors. See Further Details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

TAU

          TAU is DOUBLE PRECISION array, dimension (N-1)


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (N)

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of (ihi-ilo) elementary


  reflectors


     Q = H(ilo) H(ilo+1) . . . H(ihi-1).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on


  exit in A(i+2:ihi,i), and tau in TAU(i).


  The contents of A are illustrated by the following example, with


  n = 7, ilo = 2 and ihi = 6:


  on entry,                        on exit,


  ( a   a   a   a   a   a   a )    (  a   a   h   h   h   h   a )


  (     a   a   a   a   a   a )    (      a   h   h   h   h   a )


  (     a   a   a   a   a   a )    (      h   h   h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  h   h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  v3  h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  v3  v4  h   h   h )


  (                         a )    (                          a )


  where a denotes an element of the original matrix A, h denotes a


  modified element of the upper Hessenberg matrix H, and vi denotes an


  element of the vector defining H(i).

 DGEHRD reduces a real general matrix A to upper Hessenberg form H by


 an orthogonal similarity transformation:  Q**T * A * Q = H .

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          It is assumed that A is already upper triangular in rows


          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally


          set by a previous call to DGEBAL; otherwise they should be


          set to 1 and N respectively. See Further Details.


          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the N-by-N general matrix to be reduced.


          On exit, the upper triangle and the first subdiagonal of A


          are overwritten with the upper Hessenberg matrix H, and the


          elements below the first subdiagonal, with the array TAU,


          represent the orthogonal matrix Q as a product of elementary


          reflectors. See Further Details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

TAU

          TAU is DOUBLE PRECISION array, dimension (N-1)


          The scalar factors of the elementary reflectors (see Further


          Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to


          zero.

WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The length of the array WORK.  LWORK >= max(1,N).


          For good performance, LWORK should generally be larger.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of (ihi-ilo) elementary


  reflectors


     Q = H(ilo) H(ilo+1) . . . H(ihi-1).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on


  exit in A(i+2:ihi,i), and tau in TAU(i).


  The contents of A are illustrated by the following example, with


  n = 7, ilo = 2 and ihi = 6:


  on entry,                        on exit,


  ( a   a   a   a   a   a   a )    (  a   a   h   h   h   h   a )


  (     a   a   a   a   a   a )    (      a   h   h   h   h   a )


  (     a   a   a   a   a   a )    (      h   h   h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  h   h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  v3  h   h   h   h )


  (     a   a   a   a   a   a )    (      v2  v3  v4  h   h   h )


  (                         a )    (                          a )


  where a denotes an element of the original matrix A, h denotes a


  modified element of the upper Hessenberg matrix H, and vi denotes an


  element of the vector defining H(i).


  This file is a slight modification of LAPACK-3.0's DGEHRD


  subroutine incorporating improvements proposed by Quintana-Orti and


  Van de Geijn (2006). (See DLAHR2.)

 DGELQ2 computes an LQ factorization of a real m-by-n matrix A:


    A = ( L 0 ) *  Q


 where:


    Q is a n-by-n orthogonal matrix;


    L is a lower-triangular m-by-m matrix;


    0 is a m-by-(n-m) zero matrix, if m < n.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix A.


          On exit, the elements on and below the diagonal of the array


          contain the m by min(m,n) lower trapezoidal matrix L (L is


          lower triangular if m <= n); the elements above the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of elementary reflectors (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (M)

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(k) . . . H(2) H(1), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),


  and tau in TAU(i).

 DGELQF computes an LQ factorization of a real M-by-N matrix A:


    A = ( L 0 ) *  Q


 where:


    Q is a N-by-N orthogonal matrix;


    L is a lower-triangular M-by-M matrix;


    0 is a M-by-(N-M) zero matrix, if M < N.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and below the diagonal of the array


          contain the m-by-min(m,n) lower trapezoidal matrix L (L is


          lower triangular if m <= n); the elements above the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of elementary reflectors (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,M).


          For optimum performance LWORK >= M*NB, where NB is the


          optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(k) . . . H(2) H(1), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),


  and tau in TAU(i).

 DGELQT computes a blocked LQ factorization of a real M-by-N matrix A


 using the compact WY representation of Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

MB

          MB is INTEGER


          The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and below the diagonal of the array


          contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is


          lower triangular if M <= N); the elements above the diagonal


          are the rows of V.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is DOUBLE PRECISION array, dimension (LDT,MIN(M,N))


          The upper triangular block reflectors stored in compact form


          as a sequence of upper triangular blocks.  See below


          for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

WORK

          WORK is DOUBLE PRECISION array, dimension (MB*N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (         1 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.


  Let K=MIN(M,N).  The number of blocks is B = ceiling(K/MB), where each


  block is of order MB except for the last block, which is of order


  IB = K - (B-1)*MB.  For each of the B blocks, a upper triangular block


  reflector factor is computed: T1, T2, ..., TB.  The MB-by-MB (and IB-by-IB


  for the last block) T's are stored in the MB-by-K matrix T as


               T = (T1 T2 ... TB).

 DGELQT3 recursively computes a LQ factorization of a real M-by-N


 matrix A, using the compact WY representation of Q.


 Based on the algorithm of Elmroth and Gustavson,


 IBM J. Res. Develop. Vol 44 No. 4 July 2000.

M

          M is INTEGER


          The number of rows of the matrix A.  M =< N.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the real M-by-N matrix A.  On exit, the elements on and


          below the diagonal contain the N-by-N lower triangular matrix L; the


          elements above the diagonal are the rows of V.  See below for


          further details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is DOUBLE PRECISION array, dimension (LDT,N)


          The N-by-N upper triangular factor of the block reflector.


          The elements on and above the diagonal contain the block


          reflector T; the elements below the diagonal are not used.


          See below for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max(1,N).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (     1  v3 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The


  block reflector H is then given by


               H = I - V * T * V**T


  where V**T is the transpose of V.


  For details of the algorithm, see Elmroth and Gustavson (cited above).

 DGEMLQT overwrites the general real M-by-N matrix C with


                 SIDE = 'L'     SIDE = 'R'


 TRANS = 'N':      Q C            C Q


 TRANS = 'T':   Q**T C            C Q**T


 where Q is a real orthogonal matrix defined as the product of K


 elementary reflectors:


       Q = H(1) H(2) . . . H(K) = I - V T V**T


 generated using the compact WY representation as returned by DGELQT.


 Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'.

SIDE

          SIDE is CHARACTER*1


          = 'L': apply Q or Q**T from the Left;


          = 'R': apply Q or Q**T from the Right.

TRANS

          TRANS is CHARACTER*1


          = 'N':  No transpose, apply Q;


          = 'C':  Transpose, apply Q**T.

M

          M is INTEGER


          The number of rows of the matrix C. M >= 0.

N

          N is INTEGER


          The number of columns of the matrix C. N >= 0.

K

          K is INTEGER


          The number of elementary reflectors whose product defines


          the matrix Q.


          If SIDE = 'L', M >= K >= 0;


          if SIDE = 'R', N >= K >= 0.

MB

          MB is INTEGER


          The block size used for the storage of T.  K >= MB >= 1.


          This must be the same value of MB used to generate T


          in DGELQT.

V

          V is DOUBLE PRECISION array, dimension


                               (LDV,M) if SIDE = 'L',


                               (LDV,N) if SIDE = 'R'


          The i-th row must contain the vector which defines the


          elementary reflector H(i), for i = 1,2,...,k, as returned by


          DGELQT in the first K rows of its array argument A.

LDV

          LDV is INTEGER


          The leading dimension of the array V.  LDV >= max(1,K).

T

          T is DOUBLE PRECISION array, dimension (LDT,K)


          The upper triangular factors of the block reflectors


          as returned by DGELQT, stored as a MB-by-K matrix.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

C

          C is DOUBLE PRECISION array, dimension (LDC,N)


          On entry, the M-by-N matrix C.


          On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q.

LDC

          LDC is INTEGER


          The leading dimension of the array C. LDC >= max(1,M).

WORK

          WORK is DOUBLE PRECISION array. The dimension of


          WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEMQRT overwrites the general real M-by-N matrix C with


                 SIDE = 'L'     SIDE = 'R'


 TRANS = 'N':      Q C            C Q


 TRANS = 'T':   Q**T C            C Q**T


 where Q is a real orthogonal matrix defined as the product of K


 elementary reflectors:


       Q = H(1) H(2) . . . H(K) = I - V T V**T


 generated using the compact WY representation as returned by DGEQRT.


 Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'.

SIDE

          SIDE is CHARACTER*1


          = 'L': apply Q or Q**T from the Left;


          = 'R': apply Q or Q**T from the Right.

TRANS

          TRANS is CHARACTER*1


          = 'N':  No transpose, apply Q;


          = 'C':  Transpose, apply Q**T.

M

          M is INTEGER


          The number of rows of the matrix C. M >= 0.

N

          N is INTEGER


          The number of columns of the matrix C. N >= 0.

K

          K is INTEGER


          The number of elementary reflectors whose product defines


          the matrix Q.


          If SIDE = 'L', M >= K >= 0;


          if SIDE = 'R', N >= K >= 0.

NB

          NB is INTEGER


          The block size used for the storage of T.  K >= NB >= 1.


          This must be the same value of NB used to generate T


          in DGEQRT.

V

          V is DOUBLE PRECISION array, dimension (LDV,K)


          The i-th column must contain the vector which defines the


          elementary reflector H(i), for i = 1,2,...,k, as returned by


          DGEQRT in the first K columns of its array argument A.

LDV

          LDV is INTEGER


          The leading dimension of the array V.


          If SIDE = 'L', LDA >= max(1,M);


          if SIDE = 'R', LDA >= max(1,N).

T

          T is DOUBLE PRECISION array, dimension (LDT,K)


          The upper triangular factors of the block reflectors


          as returned by DGEQRT, stored as a NB-by-N matrix.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= NB.

C

          C is DOUBLE PRECISION array, dimension (LDC,N)


          On entry, the M-by-N matrix C.


          On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q.

LDC

          LDC is INTEGER


          The leading dimension of the array C. LDC >= max(1,M).

WORK

          WORK is DOUBLE PRECISION array. The dimension of


          WORK is N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGEQL2 computes a QL factorization of a real m by n matrix A:


 A = Q * L.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix A.


          On exit, if m >= n, the lower triangle of the subarray


          A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;


          if m <= n, the elements on and below the (n-m)-th


          superdiagonal contain the m by n lower trapezoidal matrix L;


          the remaining elements, with the array TAU, represent the


          orthogonal matrix Q as a product of elementary reflectors


          (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (N)

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(k) . . . H(2) H(1), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in


  A(1:m-k+i-1,n-k+i), and tau in TAU(i).

 DGEQLF computes a QL factorization of a real M-by-N matrix A:


 A = Q * L.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit,


          if m >= n, the lower triangle of the subarray


          A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;


          if m <= n, the elements on and below the (n-m)-th


          superdiagonal contain the M-by-N lower trapezoidal matrix L;


          the remaining elements, with the array TAU, represent the


          orthogonal matrix Q as a product of elementary reflectors


          (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          For optimum performance LWORK >= N*NB, where NB is the


          optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(k) . . . H(2) H(1), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in


  A(1:m-k+i-1,n-k+i), and tau in TAU(i).

 DGEQP3 computes a QR factorization with column pivoting of a


 matrix A:  A*P = Q*R  using Level 3 BLAS.

M

          M is INTEGER


          The number of rows of the matrix A. M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the upper triangle of the array contains the


          min(M,N)-by-N upper trapezoidal matrix R; the elements below


          the diagonal, together with the array TAU, represent the


          orthogonal matrix Q as a product of min(M,N) elementary


          reflectors.

LDA

          LDA is INTEGER


          The leading dimension of the array A. LDA >= max(1,M).

JPVT

          JPVT is INTEGER array, dimension (N)


          On entry, if JPVT(J).ne.0, the J-th column of A is permuted


          to the front of A*P (a leading column); if JPVT(J)=0,


          the J-th column of A is a free column.


          On exit, if JPVT(J)=K, then the J-th column of A*P was the


          the K-th column of A.

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors.

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO=0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK. LWORK >= 3*N+1.


          For optimal performance LWORK >= 2*N+( N+1 )*NB, where NB


          is the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0: successful exit.


          < 0: if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real/complex vector


  with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in


  A(i+1:m,i), and tau in TAU(i).

G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain X. Sun, Computer Science Dept., Duke University, USA

 DGEQR2 computes a QR factorization of a real m-by-n matrix A:


    A = Q * ( R ),


            ( 0 )


 where:


    Q is a m-by-m orthogonal matrix;


    R is an upper-triangular n-by-n matrix;


    0 is a (m-n)-by-n zero matrix, if m > n.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix A.


          On exit, the elements on and above the diagonal of the array


          contain the min(m,n) by n upper trapezoidal matrix R (R is


          upper triangular if m >= n); the elements below the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of elementary reflectors (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (N)

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),


  and tau in TAU(i).

 DGEQR2P computes a QR factorization of a real m-by-n matrix A:


    A = Q * ( R ),


            ( 0 )


 where:


    Q is a m-by-m orthogonal matrix;


    R is an upper-triangular n-by-n matrix with nonnegative diagonal


    entries;


    0 is a (m-n)-by-n zero matrix, if m > n.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix A.


          On exit, the elements on and above the diagonal of the array


          contain the min(m,n) by n upper trapezoidal matrix R (R is


          upper triangular if m >= n). The diagonal entries of R are


          nonnegative; the elements below the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of elementary reflectors (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (N)

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),


  and tau in TAU(i).


 See Lapack Working Note 203 for details

 DGEQRF computes a QR factorization of a real M-by-N matrix A:


    A = Q * ( R ),


            ( 0 )


 where:


    Q is a M-by-M orthogonal matrix;


    R is an upper-triangular N-by-N matrix;


    0 is a (M-N)-by-N zero matrix, if M > N.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and above the diagonal of the array


          contain the min(M,N)-by-N upper trapezoidal matrix R (R is


          upper triangular if m >= n); the elements below the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of min(m,n) elementary reflectors (see Further


          Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.


          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise.


          For optimum performance LWORK >= N*NB, where NB is


          the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),


  and tau in TAU(i).

 DGEQR2P computes a QR factorization of a real M-by-N matrix A:


    A = Q * ( R ),


            ( 0 )


 where:


    Q is a M-by-M orthogonal matrix;


    R is an upper-triangular N-by-N matrix with nonnegative diagonal


    entries;


    0 is a (M-N)-by-N zero matrix, if M > N.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and above the diagonal of the array


          contain the min(M,N)-by-N upper trapezoidal matrix R (R is


          upper triangular if m >= n). The diagonal entries of R


          are nonnegative; the elements below the diagonal,


          with the array TAU, represent the orthogonal matrix Q as a


          product of min(m,n) elementary reflectors (see Further


          Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          For optimum performance LWORK >= N*NB, where NB is


          the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),


  and tau in TAU(i).


 See Lapack Working Note 203 for details

 DGEQRT computes a blocked QR factorization of a real M-by-N matrix A


 using the compact WY representation of Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

NB

          NB is INTEGER


          The block size to be used in the blocked QR.  MIN(M,N) >= NB >= 1.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and above the diagonal of the array


          contain the min(M,N)-by-N upper trapezoidal matrix R (R is


          upper triangular if M >= N); the elements below the diagonal


          are the columns of V.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is DOUBLE PRECISION array, dimension (LDT,MIN(M,N))


          The upper triangular block reflectors stored in compact form


          as a sequence of upper triangular blocks.  See below


          for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= NB.

WORK

          WORK is DOUBLE PRECISION array, dimension (NB*N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th column


  below the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1       )


                   ( v1  1    )


                   ( v1 v2  1 )


                   ( v1 v2 v3 )


                   ( v1 v2 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.


  Let K=MIN(M,N).  The number of blocks is B = ceiling(K/NB), where each


  block is of order NB except for the last block, which is of order


  IB = K - (B-1)*NB.  For each of the B blocks, a upper triangular block


  reflector factor is computed: T1, T2, ..., TB.  The NB-by-NB (and IB-by-IB


  for the last block) T's are stored in the NB-by-K matrix T as


               T = (T1 T2 ... TB).

 DGEQRT2 computes a QR factorization of a real M-by-N matrix A,


 using the compact WY representation of Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= N.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the real M-by-N matrix A.  On exit, the elements on and


          above the diagonal contain the N-by-N upper triangular matrix R; the


          elements below the diagonal are the columns of V.  See below for


          further details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is DOUBLE PRECISION array, dimension (LDT,N)


          The N-by-N upper triangular factor of the block reflector.


          The elements on and above the diagonal contain the block


          reflector T; the elements below the diagonal are not used.


          See below for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max(1,N).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th column


  below the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1       )


                   ( v1  1    )


                   ( v1 v2  1 )


                   ( v1 v2 v3 )


                   ( v1 v2 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The


  block reflector H is then given by


               H = I - V * T * V**T


  where V**T is the transpose of V.

 DGEQRT3 recursively computes a QR factorization of a real M-by-N


 matrix A, using the compact WY representation of Q.


 Based on the algorithm of Elmroth and Gustavson,


 IBM J. Res. Develop. Vol 44 No. 4 July 2000.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= N.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the real M-by-N matrix A.  On exit, the elements on and


          above the diagonal contain the N-by-N upper triangular matrix R; the


          elements below the diagonal are the columns of V.  See below for


          further details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is DOUBLE PRECISION array, dimension (LDT,N)


          The N-by-N upper triangular factor of the block reflector.


          The elements on and above the diagonal contain the block


          reflector T; the elements below the diagonal are not used.


          See below for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max(1,N).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th column


  below the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1       )


                   ( v1  1    )


                   ( v1 v2  1 )


                   ( v1 v2 v3 )


                   ( v1 v2 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The


  block reflector H is then given by


               H = I - V * T * V**T


  where V**T is the transpose of V.


  For details of the algorithm, see Elmroth and Gustavson (cited above).

 DGERFS improves the computed solution to a system of linear


 equations and provides error bounds and backward error estimates for


 the solution.

TRANS

          TRANS is CHARACTER*1


          Specifies the form of the system of equations:


          = 'N':  A * X = B     (No transpose)


          = 'T':  A**T * X = B  (Transpose)


          = 'C':  A**H * X = B  (Conjugate transpose = Transpose)

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

NRHS

          NRHS is INTEGER


          The number of right hand sides, i.e., the number of columns


          of the matrices B and X.  NRHS >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          The original N-by-N matrix A.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

AF

          AF is DOUBLE PRECISION array, dimension (LDAF,N)


          The factors L and U from the factorization A = P*L*U


          as computed by DGETRF.

LDAF

          LDAF is INTEGER


          The leading dimension of the array AF.  LDAF >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices from DGETRF; for 1<=i<=N, row i of the


          matrix was interchanged with row IPIV(i).

B

          B is DOUBLE PRECISION array, dimension (LDB,NRHS)


          The right hand side matrix B.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max(1,N).

X

          X is DOUBLE PRECISION array, dimension (LDX,NRHS)


          On entry, the solution matrix X, as computed by DGETRS.


          On exit, the improved solution matrix X.

LDX

          LDX is INTEGER


          The leading dimension of the array X.  LDX >= max(1,N).

FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)


          The estimated forward error bound for each solution vector


          X(j) (the j-th column of the solution matrix X).


          If XTRUE is the true solution corresponding to X(j), FERR(j)


          is an estimated upper bound for the magnitude of the largest


          element in (X(j) - XTRUE) divided by the magnitude of the


          largest element in X(j).  The estimate is as reliable as


          the estimate for RCOND, and is almost always a slight


          overestimate of the true error.

BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)


          The componentwise relative backward error of each solution


          vector X(j) (i.e., the smallest relative change in


          any element of A or B that makes X(j) an exact solution).

WORK

          WORK is DOUBLE PRECISION array, dimension (3*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

  ITMAX is the maximum number of steps of iterative refinement.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

    DGERFSX improves the computed solution to a system of linear


    equations and provides error bounds and backward error estimates


    for the solution.  In addition to normwise error bound, the code


    provides maximum componentwise error bound if possible.  See


    comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the


    error bounds.


    The original system of linear equations may have been equilibrated


    before calling this routine, as described by arguments EQUED, R


    and C below. In this case, the solution and error bounds returned


    are for the original unequilibrated system.

     Some optional parameters are bundled in the PARAMS array.  These


     settings determine how refinement is performed, but often the


     defaults are acceptable.  If the defaults are acceptable, users


     can pass NPARAMS = 0 which prevents the source code from accessing


     the PARAMS argument.

TRANS

          TRANS is CHARACTER*1


     Specifies the form of the system of equations:


       = 'N':  A * X = B     (No transpose)


       = 'T':  A**T * X = B  (Transpose)


       = 'C':  A**H * X = B  (Conjugate transpose = Transpose)

EQUED

          EQUED is CHARACTER*1


     Specifies the form of equilibration that was done to A


     before calling this routine. This is needed to compute


     the solution and error bounds correctly.


       = 'N':  No equilibration


       = 'R':  Row equilibration, i.e., A has been premultiplied by


               diag(R).


       = 'C':  Column equilibration, i.e., A has been postmultiplied


               by diag(C).


       = 'B':  Both row and column equilibration, i.e., A has been


               replaced by diag(R) * A * diag(C).


               The right hand side B has been changed accordingly.

N

          N is INTEGER


     The order of the matrix A.  N >= 0.

NRHS

          NRHS is INTEGER


     The number of right hand sides, i.e., the number of columns


     of the matrices B and X.  NRHS >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


     The original N-by-N matrix A.

LDA

          LDA is INTEGER


     The leading dimension of the array A.  LDA >= max(1,N).

AF

          AF is DOUBLE PRECISION array, dimension (LDAF,N)


     The factors L and U from the factorization A = P*L*U


     as computed by DGETRF.

LDAF

          LDAF is INTEGER


     The leading dimension of the array AF.  LDAF >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


     The pivot indices from DGETRF; for 1<=i<=N, row i of the


     matrix was interchanged with row IPIV(i).

R

          R is DOUBLE PRECISION array, dimension (N)


     The row scale factors for A.  If EQUED = 'R' or 'B', A is


     multiplied on the left by diag(R); if EQUED = 'N' or 'C', R


     is not accessed.


     If R is accessed, each element of R should be a power of the radix


     to ensure a reliable solution and error estimates. Scaling by


     powers of the radix does not cause rounding errors unless the


     result underflows or overflows. Rounding errors during scaling


     lead to refining with a matrix that is not equivalent to the


     input matrix, producing error estimates that may not be


     reliable.

C

          C is DOUBLE PRECISION array, dimension (N)


     The column scale factors for A.  If EQUED = 'C' or 'B', A is


     multiplied on the right by diag(C); if EQUED = 'N' or 'R', C


     is not accessed.


     If C is accessed, each element of C should be a power of the radix


     to ensure a reliable solution and error estimates. Scaling by


     powers of the radix does not cause rounding errors unless the


     result underflows or overflows. Rounding errors during scaling


     lead to refining with a matrix that is not equivalent to the


     input matrix, producing error estimates that may not be


     reliable.

B

          B is DOUBLE PRECISION array, dimension (LDB,NRHS)


     The right hand side matrix B.

LDB

          LDB is INTEGER


     The leading dimension of the array B.  LDB >= max(1,N).

X

          X is DOUBLE PRECISION array, dimension (LDX,NRHS)


     On entry, the solution matrix X, as computed by DGETRS.


     On exit, the improved solution matrix X.

LDX

          LDX is INTEGER


     The leading dimension of the array X.  LDX >= max(1,N).

RCOND

          RCOND is DOUBLE PRECISION


     Reciprocal scaled condition number.  This is an estimate of the


     reciprocal Skeel condition number of the matrix A after


     equilibration (if done).  If this is less than the machine


     precision (in particular, if it is zero), the matrix is singular


     to working precision.  Note that the error may still be small even


     if this number is very small and the matrix appears ill-


     conditioned.

BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)


     Componentwise relative backward error.  This is the


     componentwise relative backward error of each solution vector X(j)


     (i.e., the smallest relative change in any element of A or B that


     makes X(j) an exact solution).

N_ERR_BNDS

          N_ERR_BNDS is INTEGER


     Number of error bounds to return for each right hand side


     and each type (normwise or componentwise).  See ERR_BNDS_NORM and


     ERR_BNDS_COMP below.

ERR_BNDS_NORM

          ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)


     For each right-hand side, this array contains information about


     various error bounds and condition numbers corresponding to the


     normwise relative error, which is defined as follows:


     Normwise relative error in the ith solution vector:


             max_j (abs(XTRUE(j,i) - X(j,i)))


            ------------------------------


                  max_j abs(X(j,i))


     The array is indexed by the type of error information as described


     below. There currently are up to three pieces of information


     returned.


     The first index in ERR_BNDS_NORM(i,:) corresponds to the ith


     right-hand side.


     The second index in ERR_BNDS_NORM(:,err) contains the following


     three fields:


     err = 1 'Trust/don't trust' boolean. Trust the answer if the


              reciprocal condition number is less than the threshold


              sqrt(n) * dlamch('Epsilon').


     err = 2 'Guaranteed' error bound: The estimated forward error,


              almost certainly within a factor of 10 of the true error


              so long as the next entry is greater than the threshold


              sqrt(n) * dlamch('Epsilon'). This error bound should only


              be trusted if the previous boolean is true.


     err = 3  Reciprocal condition number: Estimated normwise


              reciprocal condition number.  Compared with the threshold


              sqrt(n) * dlamch('Epsilon') to determine if the error


              estimate is 'guaranteed'. These reciprocal condition


              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some


              appropriately scaled matrix Z.


              Let Z = S*A, where S scales each row by a power of the


              radix so all absolute row sums of Z are approximately 1.


     See Lapack Working Note 165 for further details and extra


     cautions.

ERR_BNDS_COMP

          ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)


     For each right-hand side, this array contains information about


     various error bounds and condition numbers corresponding to the


     componentwise relative error, which is defined as follows:


     Componentwise relative error in the ith solution vector:


                    abs(XTRUE(j,i) - X(j,i))


             max_j ----------------------


                         abs(X(j,i))


     The array is indexed by the right-hand side i (on which the


     componentwise relative error depends), and the type of error


     information as described below. There currently are up to three


     pieces of information returned for each right-hand side. If


     componentwise accuracy is not requested (PARAMS(3) = 0.0), then


     ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS < 3, then at most


     the first (:,N_ERR_BNDS) entries are returned.


     The first index in ERR_BNDS_COMP(i,:) corresponds to the ith


     right-hand side.


     The second index in ERR_BNDS_COMP(:,err) contains the following


     three fields:


     err = 1 'Trust/don't trust' boolean. Trust the answer if the


              reciprocal condition number is less than the threshold


              sqrt(n) * dlamch('Epsilon').


     err = 2 'Guaranteed' error bound: The estimated forward error,


              almost certainly within a factor of 10 of the true error


              so long as the next entry is greater than the threshold


              sqrt(n) * dlamch('Epsilon'). This error bound should only


              be trusted if the previous boolean is true.


     err = 3  Reciprocal condition number: Estimated componentwise


              reciprocal condition number.  Compared with the threshold


              sqrt(n) * dlamch('Epsilon') to determine if the error


              estimate is 'guaranteed'. These reciprocal condition


              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some


              appropriately scaled matrix Z.


              Let Z = S*(A*diag(x)), where x is the solution for the


              current right-hand side and S scales each row of


              A*diag(x) by a power of the radix so all absolute row


              sums of Z are approximately 1.


     See Lapack Working Note 165 for further details and extra


     cautions.

NPARAMS

          NPARAMS is INTEGER


     Specifies the number of parameters set in PARAMS.  If <= 0, the


     PARAMS array is never referenced and default values are used.

PARAMS

          PARAMS is DOUBLE PRECISION array, dimension (NPARAMS)


     Specifies algorithm parameters.  If an entry is < 0.0, then


     that entry will be filled with default value used for that


     parameter.  Only positions up to NPARAMS are accessed; defaults


     are used for higher-numbered parameters.


       PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative


            refinement or not.


         Default: 1.0D+0


            = 0.0:  No refinement is performed, and no error bounds are


                    computed.


            = 1.0:  Use the double-precision refinement algorithm,


                    possibly with doubled-single computations if the


                    compilation environment does not support DOUBLE


                    PRECISION.


              (other values are reserved for future use)


       PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual


            computations allowed for refinement.


         Default: 10


         Aggressive: Set to 100 to permit convergence using approximate


                     factorizations or factorizations other than LU. If


                     the factorization uses a technique other than


                     Gaussian elimination, the guarantees in


                     err_bnds_norm and err_bnds_comp may no longer be


                     trustworthy.


       PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code


            will attempt to find a solution with small componentwise


            relative error in the double-precision algorithm.  Positive


            is true, 0.0 is false.


         Default: 1.0 (attempt componentwise convergence)

WORK

          WORK is DOUBLE PRECISION array, dimension (4*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is INTEGER


       = 0:  Successful exit. The solution to every right-hand side is


         guaranteed.


       < 0:  If INFO = -i, the i-th argument had an illegal value


       > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization


         has been completed, but the factor U is exactly singular, so


         the solution and error bounds could not be computed. RCOND = 0


         is returned.


       = N+J: The solution corresponding to the Jth right-hand side is


         not guaranteed. The solutions corresponding to other right-


         hand sides K with K > J may not be guaranteed as well, but


         only the first such right-hand side is reported. If a small


         componentwise error is not requested (PARAMS(3) = 0.0) then


         the Jth right-hand side is the first with a normwise error


         bound that is not guaranteed (the smallest J such


         that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)


         the Jth right-hand side is the first with either a normwise or


         componentwise error bound that is not guaranteed (the smallest


         J such that either ERR_BNDS_NORM(J,1) = 0.0 or


         ERR_BNDS_COMP(J,1) = 0.0). See the definition of


         ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information


         about all of the right-hand sides check ERR_BNDS_NORM or


         ERR_BNDS_COMP.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGERQ2 computes an RQ factorization of a real m by n matrix A:


 A = R * Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix A.


          On exit, if m <= n, the upper triangle of the subarray


          A(1:m,n-m+1:n) contains the m by m upper triangular matrix R;


          if m >= n, the elements on and above the (m-n)-th subdiagonal


          contain the m by n upper trapezoidal matrix R; the remaining


          elements, with the array TAU, represent the orthogonal matrix


          Q as a product of elementary reflectors (see Further


          Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (M)

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in


  A(m-k+i,1:n-k+i-1), and tau in TAU(i).

 DGERQF computes an RQ factorization of a real M-by-N matrix A:


 A = R * Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit,


          if m <= n, the upper triangle of the subarray


          A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R;


          if m >= n, the elements on and above the (m-n)-th subdiagonal


          contain the M-by-N upper trapezoidal matrix R;


          the remaining elements, with the array TAU, represent the


          orthogonal matrix Q as a product of min(m,n) elementary


          reflectors (see Further Details).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

TAU

          TAU is DOUBLE PRECISION array, dimension (min(M,N))


          The scalar factors of the elementary reflectors (see Further


          Details).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.


          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= M, otherwise.


          For optimum performance LWORK >= M*NB, where NB is


          the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix Q is represented as a product of elementary reflectors


     Q = H(1) H(2) . . . H(k), where k = min(m,n).


  Each H(i) has the form


     H(i) = I - tau * v * v**T


  where tau is a real scalar, and v is a real vector with


  v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in


  A(m-k+i,1:n-k+i-1), and tau in TAU(i).

 DGESVJ computes the singular value decomposition (SVD) of a real


 M-by-N matrix A, where M >= N. The SVD of A is written as


                                    [++]   [xx]   [x0]   [xx]


              A = U * SIGMA * V^t,  [++] = [xx] * [ox] * [xx]


                                    [++]   [xx]


 where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal


 matrix, and V is an N-by-N orthogonal matrix. The diagonal elements


 of SIGMA are the singular values of A. The columns of U and V are the


 left and the right singular vectors of A, respectively.


 DGESVJ can sometimes compute tiny singular values and their singular vectors much


 more accurately than other SVD routines, see below under Further Details.

JOBA

          JOBA is CHARACTER*1


          Specifies the structure of A.


          = 'L': The input matrix A is lower triangular;


          = 'U': The input matrix A is upper triangular;


          = 'G': The input matrix A is general M-by-N matrix, M >= N.

JOBU

          JOBU is CHARACTER*1


          Specifies whether to compute the left singular vectors


          (columns of U):


          = 'U': The left singular vectors corresponding to the nonzero


                 singular values are computed and returned in the leading


                 columns of A. See more details in the description of A.


                 The default numerical orthogonality threshold is set to


                 approximately TOL=CTOL*EPS, CTOL=DSQRT(M), EPS=DLAMCH('E').


          = 'C': Analogous to JOBU='U', except that user can control the


                 level of numerical orthogonality of the computed left


                 singular vectors. TOL can be set to TOL = CTOL*EPS, where


                 CTOL is given on input in the array WORK.


                 No CTOL smaller than ONE is allowed. CTOL greater


                 than 1 / EPS is meaningless. The option 'C'


                 can be used if M*EPS is satisfactory orthogonality


                 of the computed left singular vectors, so CTOL=M could


                 save few sweeps of Jacobi rotations.


                 See the descriptions of A and WORK(1).


          = 'N': The matrix U is not computed. However, see the


                 description of A.

JOBV

          JOBV is CHARACTER*1


          Specifies whether to compute the right singular vectors, that


          is, the matrix V:


          = 'V':  the matrix V is computed and returned in the array V


          = 'A':  the Jacobi rotations are applied to the MV-by-N


                  array V. In other words, the right singular vector


                  matrix V is not computed explicitly, instead it is


                  applied to an MV-by-N matrix initially stored in the


                  first MV rows of V.


          = 'N':  the matrix V is not computed and the array V is not


                  referenced

M

          M is INTEGER


          The number of rows of the input matrix A. 1/DLAMCH('E') > M >= 0.

N

          N is INTEGER


          The number of columns of the input matrix A.


          M >= N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit :


          If JOBU = 'U' .OR. JOBU = 'C' :


                 If INFO = 0 :


                 RANKA orthonormal columns of U are returned in the


                 leading RANKA columns of the array A. Here RANKA <= N


                 is the number of computed singular values of A that are


                 above the underflow threshold DLAMCH('S'). The singular


                 vectors corresponding to underflowed or zero singular


                 values are not computed. The value of RANKA is returned


                 in the array WORK as RANKA=NINT(WORK(2)). Also see the


                 descriptions of SVA and WORK. The computed columns of U


                 are mutually numerically orthogonal up to approximately


                 TOL=DSQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU = 'C'),


                 see the description of JOBU.


                 If INFO > 0 :


                 the procedure DGESVJ did not converge in the given number


                 of iterations (sweeps). In that case, the computed


                 columns of U may not be orthogonal up to TOL. The output


                 U (stored in A), SIGMA (given by the computed singular


                 values in SVA(1:N)) and V is still a decomposition of the


                 input matrix A in the sense that the residual


                 ||A-SCALE*U*SIGMA*V^T||_2 / ||A||_2 is small.


          If JOBU = 'N' :


                 If INFO = 0 :


                 Note that the left singular vectors are 'for free' in the


                 one-sided Jacobi SVD algorithm. However, if only the


                 singular values are needed, the level of numerical


                 orthogonality of U is not an issue and iterations are


                 stopped when the columns of the iterated matrix are


                 numerically orthogonal up to approximately M*EPS. Thus,


                 on exit, A contains the columns of U scaled with the


                 corresponding singular values.


                 If INFO > 0 :


                 the procedure DGESVJ did not converge in the given number


                 of iterations (sweeps).

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

SVA

          SVA is DOUBLE PRECISION array, dimension (N)


          On exit :


          If INFO = 0 :


          depending on the value SCALE = WORK(1), we have:


                 If SCALE = ONE :


                 SVA(1:N) contains the computed singular values of A.


                 During the computation SVA contains the Euclidean column


                 norms of the iterated matrices in the array A.


                 If SCALE .NE. ONE :


                 The singular values of A are SCALE*SVA(1:N), and this


                 factored representation is due to the fact that some of the


                 singular values of A might underflow or overflow.


          If INFO > 0 :


          the procedure DGESVJ did not converge in the given number of


          iterations (sweeps) and SCALE*SVA(1:N) may not be accurate.

MV

          MV is INTEGER


          If JOBV = 'A', then the product of Jacobi rotations in DGESVJ


          is applied to the first MV rows of V. See the description of JOBV.

V

          V is DOUBLE PRECISION array, dimension (LDV,N)


          If JOBV = 'V', then V contains on exit the N-by-N matrix of


                         the right singular vectors;


          If JOBV = 'A', then V contains the product of the computed right


                         singular vector matrix and the initial matrix in


                         the array V.


          If JOBV = 'N', then V is not referenced.

LDV

          LDV is INTEGER


          The leading dimension of the array V, LDV >= 1.


          If JOBV = 'V', then LDV >= max(1,N).


          If JOBV = 'A', then LDV >= max(1,MV) .

WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


          On entry :


          If JOBU = 'C' :


          WORK(1) = CTOL, where CTOL defines the threshold for convergence.


                    The process stops if all columns of A are mutually


                    orthogonal up to CTOL*EPS, EPS=DLAMCH('E').


                    It is required that CTOL >= ONE, i.e. it is not


                    allowed to force the routine to obtain orthogonality


                    below EPS.


          On exit :


          WORK(1) = SCALE is the scaling factor such that SCALE*SVA(1:N)


                    are the computed singular values of A.


                    (See description of SVA().)


          WORK(2) = NINT(WORK(2)) is the number of the computed nonzero


                    singular values.


          WORK(3) = NINT(WORK(3)) is the number of the computed singular


                    values that are larger than the underflow threshold.


          WORK(4) = NINT(WORK(4)) is the number of sweeps of Jacobi


                    rotations needed for numerical convergence.


          WORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.


                    This is useful information in cases when DGESVJ did


                    not converge, as it can be used to estimate whether


                    the output is still useful and for post festum analysis.


          WORK(6) = the largest absolute value over all sines of the


                    Jacobi rotation angles in the last sweep. It can be


                    useful for a post festum analysis.

LWORK

          LWORK is INTEGER


          length of WORK, WORK >= MAX(6,M+N)

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, then the i-th argument had an illegal value


          > 0:  DGESVJ did not converge in the maximal allowed number (30)


                of sweeps. The output may still be useful. See the


                description of WORK.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The orthogonal N-by-N matrix V is obtained as a product of Jacobi plane


  rotations. The rotations are implemented as fast scaled rotations of


  Anda and Park [1]. In the case of underflow of the Jacobi angle, a


  modified Jacobi transformation of Drmac [4] is used. Pivot strategy uses


  column interchanges of de Rijk [2]. The relative accuracy of the computed


  singular values and the accuracy of the computed singular vectors (in


  angle metric) is as guaranteed by the theory of Demmel and Veselic [3].


  The condition number that determines the accuracy in the full rank case


  is essentially min_{D=diag} kappa(A*D), where kappa(.) is the


  spectral condition number. The best performance of this Jacobi SVD


  procedure is achieved if used in an  accelerated version of Drmac and


  Veselic [5,6], and it is the kernel routine in the SIGMA library [7].


  Some tuning parameters (marked with [TP]) are available for the


  implementer.


  The computational range for the nonzero singular values is the  machine


  number interval ( UNDERFLOW , OVERFLOW ). In extreme cases, even


  denormalized singular values can be computed with the corresponding


  gradual loss of accurate digits.

  ============


  Zlatko Drmac (Zagreb, Croatia) and Kresimir Veselic (Hagen, Germany)

 [1] A. A. Anda and H. Park: Fast plane rotations with dynamic scaling.


     SIAM J. matrix Anal. Appl., Vol. 15 (1994), pp. 162-174.


 [2] P. P. M. De Rijk: A one-sided Jacobi algorithm for computing the


     singular value decomposition on a vector computer.


     SIAM J. Sci. Stat. Comp., Vol. 10 (1998), pp. 359-371.


 [3] J. Demmel and K. Veselic: Jacobi method is more accurate than QR.


 [4] Z. Drmac: Implementation of Jacobi rotations for accurate singular


     value computation in floating point arithmetic.


     SIAM J. Sci. Comp., Vol. 18 (1997), pp. 1200-1222.


 [5] Z. Drmac and K. Veselic: New fast and accurate Jacobi SVD algorithm I.


     SIAM J. Matrix Anal. Appl. Vol. 35, No. 2 (2008), pp. 1322-1342.


     LAPACK Working note 169.


 [6] Z. Drmac and K. Veselic: New fast and accurate Jacobi SVD algorithm II.


     SIAM J. Matrix Anal. Appl. Vol. 35, No. 2 (2008), pp. 1343-1362.


     LAPACK Working note 170.


 [7] Z. Drmac: SIGMA - mathematical software library for accurate SVD, PSV,


     QSVD, (H,K)-SVD computations.


     Department of Mathematics, University of Zagreb, 2008.

  ===========================


  Please report all bugs and send interesting test examples and comments to


  drmac@math.hr. Thank you.

 DGETF2 computes an LU factorization of a general m-by-n matrix A


 using partial pivoting with row interchanges.


 The factorization has the form


    A = P * L * U


 where P is a permutation matrix, L is lower triangular with unit


 diagonal elements (lower trapezoidal if m > n), and U is upper


 triangular (upper trapezoidal if m < n).


 This is the right-looking Level 2 BLAS version of the algorithm.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the m by n matrix to be factored.


          On exit, the factors L and U from the factorization


          A = P*L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

IPIV

          IPIV is INTEGER array, dimension (min(M,N))


          The pivot indices; for 1 <= i <= min(M,N), row i of the


          matrix was interchanged with row IPIV(i).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -k, the k-th argument had an illegal value


          > 0: if INFO = k, U(k,k) is exactly zero. The factorization


               has been completed, but the factor U is exactly


               singular, and division by zero will occur if it is used


               to solve a system of equations.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGETRF computes an LU factorization of a general M-by-N matrix A


 using partial pivoting with row interchanges.


 The factorization has the form


    A = P * L * U


 where P is a permutation matrix, L is lower triangular with unit


 diagonal elements (lower trapezoidal if m > n), and U is upper


 triangular (upper trapezoidal if m < n).


 This is the right-looking Level 3 BLAS version of the algorithm.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A = P*L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

IPIV

          IPIV is INTEGER array, dimension (min(M,N))


          The pivot indices; for 1 <= i <= min(M,N), row i of the


          matrix was interchanged with row IPIV(i).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i, U(i,i) is exactly zero. The factorization


                has been completed, but the factor U is exactly


                singular, and division by zero will occur if it is used


                to solve a system of equations.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGETRF computes an LU factorization of a general M-by-N matrix A


 using partial pivoting with row interchanges.


 The factorization has the form


    A = P * L * U


 where P is a permutation matrix, L is lower triangular with unit


 diagonal elements (lower trapezoidal if m > n), and U is upper


 triangular (upper trapezoidal if m < n).


 This is the left-looking Level 3 BLAS version of the algorithm.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A = P*L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

IPIV

          IPIV is INTEGER array, dimension (min(M,N))


          The pivot indices; for 1 <= i <= min(M,N), row i of the


          matrix was interchanged with row IPIV(i).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i, U(i,i) is exactly zero. The factorization


                has been completed, but the factor U is exactly


                singular, and division by zero will occur if it is used


                to solve a system of equations.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

December 2016

 DGETRF computes an LU factorization of a general M-by-N matrix A


 using partial pivoting with row interchanges.


 The factorization has the form


    A = P * L * U


 where P is a permutation matrix, L is lower triangular with unit


 diagonal elements (lower trapezoidal if m > n), and U is upper


 triangular (upper trapezoidal if m < n).


 This code implements an iterative version of Sivan Toledo's recursive


 LU algorithm[1].  For square matrices, this iterative versions should


 be within a factor of two of the optimum number of memory transfers.


 The pattern is as follows, with the large blocks of U being updated


 in one call to DTRSM, and the dotted lines denoting sections that


 have had all pending permutations applied:


  1 2 3 4 5 6 7 8


 +-+-+---+-------+------


 | |1|   |       |


 |.+-+ 2 |       |


 | | |   |       |


 |.|.+-+-+   4   |


 | | | |1|       |


 | | |.+-+       |


 | | | | |       |


 |.|.|.|.+-+-+---+  8


 | | | | | |1|   |


 | | | | |.+-+ 2 |


 | | | | | | |   |


 | | | | |.|.+-+-+


 | | | | | | | |1|


 | | | | | | |.+-+


 | | | | | | | | |


 |.|.|.|.|.|.|.|.+-----


 | | | | | | | | |


 The 1-2-1-4-1-2-1-8-... pattern is the position of the last 1 bit in


 the binary expansion of the current column.  Each Schur update is


 applied as soon as the necessary portion of U is available.


 [1] Toledo, S. 1997. Locality of Reference in LU Decomposition with


 Partial Pivoting. SIAM J. Matrix Anal. Appl. 18, 4 (Oct. 1997),


 1065-1081. http://dx.doi.org/10.1137/S0895479896297744

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A = P*L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

IPIV

          IPIV is INTEGER array, dimension (min(M,N))


          The pivot indices; for 1 <= i <= min(M,N), row i of the


          matrix was interchanged with row IPIV(i).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i, U(i,i) is exactly zero. The factorization


                has been completed, but the factor U is exactly


                singular, and division by zero will occur if it is used


                to solve a system of equations.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

December 2016

 DGETRF2 computes an LU factorization of a general M-by-N matrix A


 using partial pivoting with row interchanges.


 The factorization has the form


    A = P * L * U


 where P is a permutation matrix, L is lower triangular with unit


 diagonal elements (lower trapezoidal if m > n), and U is upper


 triangular (upper trapezoidal if m < n).


 This is the recursive version of the algorithm. It divides


 the matrix into four submatrices:


        [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2


    A = [ -----|----- ]  with n1 = min(m,n)/2


        [  A21 | A22  ]       n2 = n-n1


                                       [ A11 ]


 The subroutine calls itself to factor [ --- ],


                                       [ A12 ]


                 [ A12 ]


 do the swaps on [ --- ], solve A12, update A22,


                 [ A22 ]


 then calls itself to factor A22 and do the swaps on A21.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A = P*L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

IPIV

          IPIV is INTEGER array, dimension (min(M,N))


          The pivot indices; for 1 <= i <= min(M,N), row i of the


          matrix was interchanged with row IPIV(i).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i, U(i,i) is exactly zero. The factorization


                has been completed, but the factor U is exactly


                singular, and division by zero will occur if it is used


                to solve a system of equations.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGETRI computes the inverse of a matrix using the LU factorization


 computed by DGETRF.


 This method inverts U and then computes inv(A) by solving the system


 inv(A)*L = inv(U) for inv(A).

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the factors L and U from the factorization


          A = P*L*U as computed by DGETRF.


          On exit, if INFO = 0, the inverse of the original matrix A.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices from DGETRF; for 1<=i<=N, row i of the


          matrix was interchanged with row IPIV(i).

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO=0, then WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          For optimal performance LWORK >= N*NB, where NB is


          the optimal blocksize returned by ILAENV.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value


          > 0:  if INFO = i, U(i,i) is exactly zero; the matrix is


                singular and its inverse could not be computed.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DGETRS solves a system of linear equations


    A * X = B  or  A**T * X = B


 with a general N-by-N matrix A using the LU factorization computed


 by DGETRF.

TRANS

          TRANS is CHARACTER*1


          Specifies the form of the system of equations:


          = 'N':  A * X = B  (No transpose)


          = 'T':  A**T* X = B  (Transpose)


          = 'C':  A**T* X = B  (Conjugate transpose = Transpose)

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

NRHS

          NRHS is INTEGER


          The number of right hand sides, i.e., the number of columns


          of the matrix B.  NRHS >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          The factors L and U from the factorization A = P*L*U


          as computed by DGETRF.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices from DGETRF; for 1<=i<=N, row i of the


          matrix was interchanged with row IPIV(i).

B

          B is DOUBLE PRECISION array, dimension (LDB,NRHS)


          On entry, the right hand side matrix B.


          On exit, the solution matrix X.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max(1,N).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DHGEQZ computes the eigenvalues of a real matrix pair (H,T),


 where H is an upper Hessenberg matrix and T is upper triangular,


 using the double-shift QZ method.


 Matrix pairs of this type are produced by the reduction to


 generalized upper Hessenberg form of a real matrix pair (A,B):


    A = Q1*H*Z1**T,  B = Q1*T*Z1**T,


 as computed by DGGHRD.


 If JOB='S', then the Hessenberg-triangular pair (H,T) is


 also reduced to generalized Schur form,


    H = Q*S*Z**T,  T = Q*P*Z**T,


 where Q and Z are orthogonal matrices, P is an upper triangular


 matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2


 diagonal blocks.


 The 1-by-1 blocks correspond to real eigenvalues of the matrix pair


 (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of


 eigenvalues.


 Additionally, the 2-by-2 upper triangular diagonal blocks of P


 corresponding to 2-by-2 blocks of S are reduced to positive diagonal


 form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0,


 P(j,j) > 0, and P(j+1,j+1) > 0.


 Optionally, the orthogonal matrix Q from the generalized Schur


 factorization may be postmultiplied into an input matrix Q1, and the


 orthogonal matrix Z may be postmultiplied into an input matrix Z1.


 If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced


 the matrix pair (A,B) to generalized upper Hessenberg form, then the


 output matrices Q1*Q and Z1*Z are the orthogonal factors from the


 generalized Schur factorization of (A,B):


    A = (Q1*Q)*S*(Z1*Z)**T,  B = (Q1*Q)*P*(Z1*Z)**T.


 To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently,


 of (A,B)) are computed as a pair of values (alpha,beta), where alpha is


 complex and beta real.


 If beta is nonzero, lambda = alpha / beta is an eigenvalue of the


 generalized nonsymmetric eigenvalue problem (GNEP)


    A*x = lambda*B*x


 and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the


 alternate form of the GNEP


    mu*A*y = B*y.


 Real eigenvalues can be read directly from the generalized Schur


 form:


   alpha = S(i,i), beta = P(i,i).


 Ref: C.B. Moler & G.W. Stewart, 'An Algorithm for Generalized Matrix


      Eigenvalue Problems', SIAM J. Numer. Anal., 10(1973),


      pp. 241--256.

JOB

          JOB is CHARACTER*1


          = 'E': Compute eigenvalues only;


          = 'S': Compute eigenvalues and the Schur form.

COMPQ

          COMPQ is CHARACTER*1


          = 'N': Left Schur vectors (Q) are not computed;


          = 'I': Q is initialized to the unit matrix and the matrix Q


                 of left Schur vectors of (H,T) is returned;


          = 'V': Q must contain an orthogonal matrix Q1 on entry and


                 the product Q1*Q is returned.

COMPZ

          COMPZ is CHARACTER*1


          = 'N': Right Schur vectors (Z) are not computed;


          = 'I': Z is initialized to the unit matrix and the matrix Z


                 of right Schur vectors of (H,T) is returned;


          = 'V': Z must contain an orthogonal matrix Z1 on entry and


                 the product Z1*Z is returned.

N

          N is INTEGER


          The order of the matrices H, T, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI mark the rows and columns of H which are in


          Hessenberg form.  It is assumed that A is already upper


          triangular in rows and columns 1:ILO-1 and IHI+1:N.


          If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0.

H

          H is DOUBLE PRECISION array, dimension (LDH, N)


          On entry, the N-by-N upper Hessenberg matrix H.


          On exit, if JOB = 'S', H contains the upper quasi-triangular


          matrix S from the generalized Schur factorization.


          If JOB = 'E', the diagonal blocks of H match those of S, but


          the rest of H is unspecified.

LDH

          LDH is INTEGER


          The leading dimension of the array H.  LDH >= max( 1, N ).

T

          T is DOUBLE PRECISION array, dimension (LDT, N)


          On entry, the N-by-N upper triangular matrix T.


          On exit, if JOB = 'S', T contains the upper triangular


          matrix P from the generalized Schur factorization;


          2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks of S


          are reduced to positive diagonal form, i.e., if H(j+1,j) is


          non-zero, then T(j+1,j) = T(j,j+1) = 0, T(j,j) > 0, and


          T(j+1,j+1) > 0.


          If JOB = 'E', the diagonal blocks of T match those of P, but


          the rest of T is unspecified.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max( 1, N ).

ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (N)


          The real parts of each scalar alpha defining an eigenvalue


          of GNEP.

ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (N)


          The imaginary parts of each scalar alpha defining an


          eigenvalue of GNEP.


          If ALPHAI(j) is zero, then the j-th eigenvalue is real; if


          positive, then the j-th and (j+1)-st eigenvalues are a


          complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).

BETA

          BETA is DOUBLE PRECISION array, dimension (N)


          The scalars beta that define the eigenvalues of GNEP.


          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and


          beta = BETA(j) represent the j-th eigenvalue of the matrix


          pair (A,B), in one of the forms lambda = alpha/beta or


          mu = beta/alpha.  Since either lambda or mu may overflow,


          they should not, in general, be computed.

Q

          Q is DOUBLE PRECISION array, dimension (LDQ, N)


          On entry, if COMPQ = 'V', the orthogonal matrix Q1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPQ = 'I', the orthogonal matrix of left Schur


          vectors of (H,T), and if COMPQ = 'V', the orthogonal matrix


          of left Schur vectors of (A,B).


          Not referenced if COMPQ = 'N'.

LDQ

          LDQ is INTEGER


          The leading dimension of the array Q.  LDQ >= 1.


          If COMPQ='V' or 'I', then LDQ >= N.

Z

          Z is DOUBLE PRECISION array, dimension (LDZ, N)


          On entry, if COMPZ = 'V', the orthogonal matrix Z1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPZ = 'I', the orthogonal matrix of


          right Schur vectors of (H,T), and if COMPZ = 'V', the


          orthogonal matrix of right Schur vectors of (A,B).


          Not referenced if COMPZ = 'N'.

LDZ

          LDZ is INTEGER


          The leading dimension of the array Z.  LDZ >= 1.


          If COMPZ='V' or 'I', then LDZ >= N.

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value


          = 1,...,N: the QZ iteration did not converge.  (H,T) is not


                     in Schur form, but ALPHAR(i), ALPHAI(i), and


                     BETA(i), i=INFO+1,...,N should be correct.


          = N+1,...,2*N: the shift calculation failed.  (H,T) is not


                     in Schur form, but ALPHAR(i), ALPHAI(i), and


                     BETA(i), i=INFO-N+1,...,N should be correct.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  Iteration counters:


  JITER  -- counts iterations.


  IITER  -- counts iterations run since ILAST was last


            changed.  This is therefore reset only when a 1-by-1 or


            2-by-2 block deflates off the bottom.

 DLA_GEAMV  performs one of the matrix-vector operations


         y := alpha*abs(A)*abs(x) + beta*abs(y),


    or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),


 where alpha and beta are scalars, x and y are vectors and A is an


 m by n matrix.


 This function is primarily used in calculating error bounds.


 To protect against underflow during evaluation, components in


 the resulting vector are perturbed away from zero by (N+1)


 times the underflow threshold.  To prevent unnecessarily large


 errors for block-structure embedded in general matrices,


 'symbolically' zero components are not perturbed.  A zero


 entry is considered 'symbolic' if all multiplications involved


 in computing that entry have at least one zero multiplicand.

TRANS

          TRANS is INTEGER


           On entry, TRANS specifies the operation to be performed as


           follows:


             BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)


             BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)


             BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)


           Unchanged on exit.

M

          M is INTEGER


           On entry, M specifies the number of rows of the matrix A.


           M must be at least zero.


           Unchanged on exit.

N

          N is INTEGER


           On entry, N specifies the number of columns of the matrix A.


           N must be at least zero.


           Unchanged on exit.

ALPHA

          ALPHA is DOUBLE PRECISION


           On entry, ALPHA specifies the scalar alpha.


           Unchanged on exit.

A

          A is DOUBLE PRECISION array, dimension ( LDA, n )


           Before entry, the leading m by n part of the array A must


           contain the matrix of coefficients.


           Unchanged on exit.

LDA

          LDA is INTEGER


           On entry, LDA specifies the first dimension of A as declared


           in the calling (sub) program. LDA must be at least


           max( 1, m ).


           Unchanged on exit.

X

          X is DOUBLE PRECISION array, dimension


           ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'


           and at least


           ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.


           Before entry, the incremented array X must contain the


           vector x.


           Unchanged on exit.

INCX

          INCX is INTEGER


           On entry, INCX specifies the increment for the elements of


           X. INCX must not be zero.


           Unchanged on exit.

BETA

          BETA is DOUBLE PRECISION


           On entry, BETA specifies the scalar beta. When BETA is


           supplied as zero then Y need not be set on input.


           Unchanged on exit.

Y

          Y is DOUBLE PRECISION array,


           dimension at least


           ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'


           and at least


           ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.


           Before entry with BETA non-zero, the incremented array Y


           must contain the vector y. On exit, Y is overwritten by the


           updated vector y.

INCY

          INCY is INTEGER


           On entry, INCY specifies the increment for the elements of


           Y. INCY must not be zero.


           Unchanged on exit.


  Level 2 Blas routine.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

    DLA_GERCOND estimates the Skeel condition number of op(A) * op2(C)


    where op2 is determined by CMODE as follows


    CMODE =  1    op2(C) = C


    CMODE =  0    op2(C) = I


    CMODE = -1    op2(C) = inv(C)


    The Skeel condition number cond(A) = norminf( |inv(A)||A| )


    is computed by computing scaling factors R such that


    diag(R)*A*op2(C) is row equilibrated and computing the standard


    infinity-norm condition number.

TRANS

          TRANS is CHARACTER*1


     Specifies the form of the system of equations:


       = 'N':  A * X = B     (No transpose)


       = 'T':  A**T * X = B  (Transpose)


       = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)

N

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


     On entry, the N-by-N matrix A.

LDA

          LDA is INTEGER


     The leading dimension of the array A.  LDA >= max(1,N).

AF

          AF is DOUBLE PRECISION array, dimension (LDAF,N)


     The factors L and U from the factorization


     A = P*L*U as computed by DGETRF.

LDAF

          LDAF is INTEGER


     The leading dimension of the array AF.  LDAF >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


     The pivot indices from the factorization A = P*L*U


     as computed by DGETRF; row i of the matrix was interchanged


     with row IPIV(i).

CMODE

          CMODE is INTEGER


     Determines op2(C) in the formula op(A) * op2(C) as follows:


     CMODE =  1    op2(C) = C


     CMODE =  0    op2(C) = I


     CMODE = -1    op2(C) = inv(C)

C

          C is DOUBLE PRECISION array, dimension (N)


     The vector C in the formula op(A) * op2(C).

INFO

          INFO is INTEGER


       = 0:  Successful exit.


     i > 0:  The ith argument is invalid.

WORK

          WORK is DOUBLE PRECISION array, dimension (3*N).


     Workspace.

IWORK

          IWORK is INTEGER array, dimension (N).


     Workspace.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DLA_GERFSX_EXTENDED improves the computed solution to a system of


 linear equations by performing extra-precise iterative refinement


 and provides error bounds and backward error estimates for the solution.


 This subroutine is called by DGERFSX to perform iterative refinement.


 In addition to normwise error bound, the code provides maximum


 componentwise error bound if possible. See comments for ERRS_N


 and ERRS_C for details of the error bounds. Note that this


 subroutine is only responsible for setting the second fields of


 ERRS_N and ERRS_C.

PREC_TYPE

          PREC_TYPE is INTEGER


     Specifies the intermediate precision to be used in refinement.


     The value is defined by ILAPREC(P) where P is a CHARACTER and P


          = 'S':  Single


          = 'D':  Double


          = 'I':  Indigenous


          = 'X' or 'E':  Extra

TRANS_TYPE

          TRANS_TYPE is INTEGER


     Specifies the transposition operation on A.


     The value is defined by ILATRANS(T) where T is a CHARACTER and T


          = 'N':  No transpose


          = 'T':  Transpose


          = 'C':  Conjugate transpose

N

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

NRHS

          NRHS is INTEGER


     The number of right-hand-sides, i.e., the number of columns of the


     matrix B.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


     On entry, the N-by-N matrix A.

LDA

          LDA is INTEGER


     The leading dimension of the array A.  LDA >= max(1,N).

AF

          AF is DOUBLE PRECISION array, dimension (LDAF,N)


     The factors L and U from the factorization


     A = P*L*U as computed by DGETRF.

LDAF

          LDAF is INTEGER


     The leading dimension of the array AF.  LDAF >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


     The pivot indices from the factorization A = P*L*U


     as computed by DGETRF; row i of the matrix was interchanged


     with row IPIV(i).

COLEQU

          COLEQU is LOGICAL


     If .TRUE. then column equilibration was done to A before calling


     this routine. This is needed to compute the solution and error


     bounds correctly.

C

          C is DOUBLE PRECISION array, dimension (N)


     The column scale factors for A. If COLEQU = .FALSE., C


     is not accessed. If C is input, each element of C should be a power


     of the radix to ensure a reliable solution and error estimates.


     Scaling by powers of the radix does not cause rounding errors unless


     the result underflows or overflows. Rounding errors during scaling


     lead to refining with a matrix that is not equivalent to the


     input matrix, producing error estimates that may not be


     reliable.

B

          B is DOUBLE PRECISION array, dimension (LDB,NRHS)


     The right-hand-side matrix B.

LDB

          LDB is INTEGER


     The leading dimension of the array B.  LDB >= max(1,N).

Y

          Y is DOUBLE PRECISION array, dimension (LDY,NRHS)


     On entry, the solution matrix X, as computed by DGETRS.


     On exit, the improved solution matrix Y.

LDY

          LDY is INTEGER


     The leading dimension of the array Y.  LDY >= max(1,N).

BERR_OUT

          BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)


     On exit, BERR_OUT(j) contains the componentwise relative backward


     error for right-hand-side j from the formula


         max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )


     where abs(Z) is the componentwise absolute value of the matrix


     or vector Z. This is computed by DLA_LIN_BERR.

N_NORMS

          N_NORMS is INTEGER


     Determines which error bounds to return (see ERRS_N


     and ERRS_C).


     If N_NORMS >= 1 return normwise error bounds.


     If N_NORMS >= 2 return componentwise error bounds.

ERRS_N

          ERRS_N is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)


     For each right-hand side, this array contains information about


     various error bounds and condition numbers corresponding to the


     normwise relative error, which is defined as follows:


     Normwise relative error in the ith solution vector:


             max_j (abs(XTRUE(j,i) - X(j,i)))


            ------------------------------


                  max_j abs(X(j,i))


     The array is indexed by the type of error information as described


     below. There currently are up to three pieces of information


     returned.


     The first index in ERRS_N(i,:) corresponds to the ith


     right-hand side.


     The second index in ERRS_N(:,err) contains the following


     three fields:


     err = 1 'Trust/don't trust' boolean. Trust the answer if the


              reciprocal condition number is less than the threshold


              sqrt(n) * slamch('Epsilon').


     err = 2 'Guaranteed' error bound: The estimated forward error,


              almost certainly within a factor of 10 of the true error


              so long as the next entry is greater than the threshold


              sqrt(n) * slamch('Epsilon'). This error bound should only


              be trusted if the previous boolean is true.


     err = 3  Reciprocal condition number: Estimated normwise


              reciprocal condition number.  Compared with the threshold


              sqrt(n) * slamch('Epsilon') to determine if the error


              estimate is 'guaranteed'. These reciprocal condition


              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some


              appropriately scaled matrix Z.


              Let Z = S*A, where S scales each row by a power of the


              radix so all absolute row sums of Z are approximately 1.


     This subroutine is only responsible for setting the second field


     above.


     See Lapack Working Note 165 for further details and extra


     cautions.

ERRS_C

          ERRS_C is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)


     For each right-hand side, this array contains information about


     various error bounds and condition numbers corresponding to the


     componentwise relative error, which is defined as follows:


     Componentwise relative error in the ith solution vector:


                    abs(XTRUE(j,i) - X(j,i))


             max_j ----------------------


                         abs(X(j,i))


     The array is indexed by the right-hand side i (on which the


     componentwise relative error depends), and the type of error


     information as described below. There currently are up to three


     pieces of information returned for each right-hand side. If


     componentwise accuracy is not requested (PARAMS(3) = 0.0), then


     ERRS_C is not accessed.  If N_ERR_BNDS < 3, then at most


     the first (:,N_ERR_BNDS) entries are returned.


     The first index in ERRS_C(i,:) corresponds to the ith


     right-hand side.


     The second index in ERRS_C(:,err) contains the following


     three fields:


     err = 1 'Trust/don't trust' boolean. Trust the answer if the


              reciprocal condition number is less than the threshold


              sqrt(n) * slamch('Epsilon').


     err = 2 'Guaranteed' error bound: The estimated forward error,


              almost certainly within a factor of 10 of the true error


              so long as the next entry is greater than the threshold


              sqrt(n) * slamch('Epsilon'). This error bound should only


              be trusted if the previous boolean is true.


     err = 3  Reciprocal condition number: Estimated componentwise


              reciprocal condition number.  Compared with the threshold


              sqrt(n) * slamch('Epsilon') to determine if the error


              estimate is 'guaranteed'. These reciprocal condition


              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some


              appropriately scaled matrix Z.


              Let Z = S*(A*diag(x)), where x is the solution for the


              current right-hand side and S scales each row of


              A*diag(x) by a power of the radix so all absolute row


              sums of Z are approximately 1.


     This subroutine is only responsible for setting the second field


     above.


     See Lapack Working Note 165 for further details and extra


     cautions.

RES

          RES is DOUBLE PRECISION array, dimension (N)


     Workspace to hold the intermediate residual.

AYB

          AYB is DOUBLE PRECISION array, dimension (N)


     Workspace. This can be the same workspace passed for Y_TAIL.

DY

          DY is DOUBLE PRECISION array, dimension (N)


     Workspace to hold the intermediate solution.

Y_TAIL

          Y_TAIL is DOUBLE PRECISION array, dimension (N)


     Workspace to hold the trailing bits of the intermediate solution.

RCOND

          RCOND is DOUBLE PRECISION


     Reciprocal scaled condition number.  This is an estimate of the


     reciprocal Skeel condition number of the matrix A after


     equilibration (if done).  If this is less than the machine


     precision (in particular, if it is zero), the matrix is singular


     to working precision.  Note that the error may still be small even


     if this number is very small and the matrix appears ill-


     conditioned.

ITHRESH

          ITHRESH is INTEGER


     The maximum number of residual computations allowed for


     refinement. The default is 10. For 'aggressive' set to 100 to


     permit convergence using approximate factorizations or


     factorizations other than LU. If the factorization uses a


     technique other than Gaussian elimination, the guarantees in


     ERRS_N and ERRS_C may no longer be trustworthy.

RTHRESH

          RTHRESH is DOUBLE PRECISION


     Determines when to stop refinement if the error estimate stops


     decreasing. Refinement will stop when the next solution no longer


     satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is


     the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The


     default value is 0.5. For 'aggressive' set to 0.9 to permit


     convergence on extremely ill-conditioned matrices. See LAWN 165


     for more details.

DZ_UB

          DZ_UB is DOUBLE PRECISION


     Determines when to start considering componentwise convergence.


     Componentwise convergence is only considered after each component


     of the solution Y is stable, which we define as the relative


     change in each component being less than DZ_UB. The default value


     is 0.25, requiring the first bit to be stable. See LAWN 165 for


     more details.

IGNORE_CWISE

          IGNORE_CWISE is LOGICAL


     If .TRUE. then ignore componentwise convergence. Default value


     is .FALSE..

INFO

          INFO is INTEGER


       = 0:  Successful exit.


       < 0:  if INFO = -i, the ith argument to DGETRS had an illegal


             value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DLA_GERPVGRW computes the reciprocal pivot growth factor


 norm(A)/norm(U). The 'max absolute element' norm is used. If this is


 much less than 1, the stability of the LU factorization of the


 (equilibrated) matrix A could be poor. This also means that the


 solution X, estimated condition numbers, and error bounds could be


 unreliable.

N

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

NCOLS

          NCOLS is INTEGER


     The number of columns of the matrix A. NCOLS >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


     On entry, the N-by-N matrix A.

LDA

          LDA is INTEGER


     The leading dimension of the array A.  LDA >= max(1,N).

AF

          AF is DOUBLE PRECISION array, dimension (LDAF,N)


     The factors L and U from the factorization


     A = P*L*U as computed by DGETRF.

LDAF

          LDAF is INTEGER


     The leading dimension of the array AF.  LDAF >= max(1,N).

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 DLAORHR_COL_GETRFNP computes the modified LU factorization without


 pivoting of a real general M-by-N matrix A. The factorization has


 the form:


     A - S = L * U,


 where:


    S is a m-by-n diagonal sign matrix with the diagonal D, so that


    D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed


    as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing


    i-1 steps of Gaussian elimination. This means that the diagonal


    element at each step of 'modified' Gaussian elimination is


    at least one in absolute value (so that division-by-zero not


    not possible during the division by the diagonal element);


    L is a M-by-N lower triangular matrix with unit diagonal elements


    (lower trapezoidal if M > N);


    and U is a M-by-N upper triangular matrix


    (upper trapezoidal if M < N).


 This routine is an auxiliary routine used in the Householder


 reconstruction routine DORHR_COL. In DORHR_COL, this routine is


 applied to an M-by-N matrix A with orthonormal columns, where each


 element is bounded by one in absolute value. With the choice of


 the matrix S above, one can show that the diagonal element at each


 step of Gaussian elimination is the largest (in absolute value) in


 the column on or below the diagonal, so that no pivoting is required


 for numerical stability [1].


 For more details on the Householder reconstruction algorithm,


 including the modified LU factorization, see [1].


 This is the blocked right-looking version of the algorithm,


 calling Level 3 BLAS to update the submatrix. To factorize a block,


 this routine calls the recursive routine DLAORHR_COL_GETRFNP2.


 [1] 'Reconstructing Householder vectors from tall-skinny QR',


     G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen,


     E. Solomonik, J. Parallel Distrib. Comput.,


     vol. 85, pp. 3-31, 2015.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A-S=L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

D

          D is DOUBLE PRECISION array, dimension min(M,N)


          The diagonal elements of the diagonal M-by-N sign matrix S,


          D(i) = S(i,i), where 1 <= i <= min(M,N). The elements can


          be only plus or minus one.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 November 2019, Igor Kozachenko,


                Computer Science Division,


                University of California, Berkeley

 DLAORHR_COL_GETRFNP2 computes the modified LU factorization without


 pivoting of a real general M-by-N matrix A. The factorization has


 the form:


     A - S = L * U,


 where:


    S is a m-by-n diagonal sign matrix with the diagonal D, so that


    D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed


    as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing


    i-1 steps of Gaussian elimination. This means that the diagonal


    element at each step of 'modified' Gaussian elimination is at


    least one in absolute value (so that division-by-zero not


    possible during the division by the diagonal element);


    L is a M-by-N lower triangular matrix with unit diagonal elements


    (lower trapezoidal if M > N);


    and U is a M-by-N upper triangular matrix


    (upper trapezoidal if M < N).


 This routine is an auxiliary routine used in the Householder


 reconstruction routine DORHR_COL. In DORHR_COL, this routine is


 applied to an M-by-N matrix A with orthonormal columns, where each


 element is bounded by one in absolute value. With the choice of


 the matrix S above, one can show that the diagonal element at each


 step of Gaussian elimination is the largest (in absolute value) in


 the column on or below the diagonal, so that no pivoting is required


 for numerical stability [1].


 For more details on the Householder reconstruction algorithm,


 including the modified LU factorization, see [1].


 This is the recursive version of the LU factorization algorithm.


 Denote A - S by B. The algorithm divides the matrix B into four


 submatrices:


        [  B11 | B12  ]  where B11 is n1 by n1,


    B = [ -----|----- ]        B21 is (m-n1) by n1,


        [  B21 | B22  ]        B12 is n1 by n2,


                               B22 is (m-n1) by n2,


                               with n1 = min(m,n)/2, n2 = n-n1.


 The subroutine calls itself to factor B11, solves for B21,


 solves for B12, updates B22, then calls itself to factor B22.


 For more details on the recursive LU algorithm, see [2].


 DLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked


 routine DLAORHR_COL_GETRFNP, which uses blocked code calling


 Level 3 BLAS to update the submatrix. However, DLAORHR_COL_GETRFNP2


 is self-sufficient and can be used without DLAORHR_COL_GETRFNP.


 [1] 'Reconstructing Householder vectors from tall-skinny QR',


     G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen,


     E. Solomonik, J. Parallel Distrib. Comput.,


     vol. 85, pp. 3-31, 2015.


 [2] 'Recursion leads to automatic variable blocking for dense linear


     algebra algorithms', F. Gustavson, IBM J. of Res. and Dev.,


     vol. 41, no. 6, pp. 737-755, 1997.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the M-by-N matrix to be factored.


          On exit, the factors L and U from the factorization


          A-S=L*U; the unit diagonal elements of L are not stored.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

D

          D is DOUBLE PRECISION array, dimension min(M,N)


          The diagonal elements of the diagonal M-by-N sign matrix S,


          D(i) = S(i,i), where 1 <= i <= min(M,N). The elements can


          be only plus or minus one.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 November 2019, Igor Kozachenko,


                Computer Science Division,


                University of California, Berkeley

 DLAQZ0 computes the eigenvalues of a real matrix pair (H,T),


 where H is an upper Hessenberg matrix and T is upper triangular,


 using the double-shift QZ method.


 Matrix pairs of this type are produced by the reduction to


 generalized upper Hessenberg form of a real matrix pair (A,B):


    A = Q1*H*Z1**T,  B = Q1*T*Z1**T,


 as computed by DGGHRD.


 If JOB='S', then the Hessenberg-triangular pair (H,T) is


 also reduced to generalized Schur form,


    H = Q*S*Z**T,  T = Q*P*Z**T,


 where Q and Z are orthogonal matrices, P is an upper triangular


 matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2


 diagonal blocks.


 The 1-by-1 blocks correspond to real eigenvalues of the matrix pair


 (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of


 eigenvalues.


 Additionally, the 2-by-2 upper triangular diagonal blocks of P


 corresponding to 2-by-2 blocks of S are reduced to positive diagonal


 form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0,


 P(j,j) > 0, and P(j+1,j+1) > 0.


 Optionally, the orthogonal matrix Q from the generalized Schur


 factorization may be postmultiplied into an input matrix Q1, and the


 orthogonal matrix Z may be postmultiplied into an input matrix Z1.


 If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced


 the matrix pair (A,B) to generalized upper Hessenberg form, then the


 output matrices Q1*Q and Z1*Z are the orthogonal factors from the


 generalized Schur factorization of (A,B):


    A = (Q1*Q)*S*(Z1*Z)**T,  B = (Q1*Q)*P*(Z1*Z)**T.


 To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently,


 of (A,B)) are computed as a pair of values (alpha,beta), where alpha is


 complex and beta real.


 If beta is nonzero, lambda = alpha / beta is an eigenvalue of the


 generalized nonsymmetric eigenvalue problem (GNEP)


    A*x = lambda*B*x


 and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the


 alternate form of the GNEP


    mu*A*y = B*y.


 Real eigenvalues can be read directly from the generalized Schur


 form:


   alpha = S(i,i), beta = P(i,i).


 Ref: C.B. Moler & G.W. Stewart, 'An Algorithm for Generalized Matrix


      Eigenvalue Problems', SIAM J. Numer. Anal., 10(1973),


      pp. 241--256.


 Ref: B. Kagstrom, D. Kressner, 'Multishift Variants of the QZ


      Algorithm with Aggressive Early Deflation', SIAM J. Numer.


      Anal., 29(2006), pp. 199--227.


 Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril 'A multishift,


      multipole rational QZ method with agressive early deflation'

WANTS

          WANTS is CHARACTER*1


          = 'E': Compute eigenvalues only;


          = 'S': Compute eigenvalues and the Schur form.

WANTQ

          WANTQ is CHARACTER*1


          = 'N': Left Schur vectors (Q) are not computed;


          = 'I': Q is initialized to the unit matrix and the matrix Q


                 of left Schur vectors of (A,B) is returned;


          = 'V': Q must contain an orthogonal matrix Q1 on entry and


                 the product Q1*Q is returned.

WANTZ

          WANTZ is CHARACTER*1


          = 'N': Right Schur vectors (Z) are not computed;


          = 'I': Z is initialized to the unit matrix and the matrix Z


                 of right Schur vectors of (A,B) is returned;


          = 'V': Z must contain an orthogonal matrix Z1 on entry and


                 the product Z1*Z is returned.

N

          N is INTEGER


          The order of the matrices A, B, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI mark the rows and columns of A which are in


          Hessenberg form.  It is assumed that A is already upper


          triangular in rows and columns 1:ILO-1 and IHI+1:N.


          If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0.

A

          A is DOUBLE PRECISION array, dimension (LDA, N)


          On entry, the N-by-N upper Hessenberg matrix A.


          On exit, if JOB = 'S', A contains the upper quasi-triangular


          matrix S from the generalized Schur factorization.


          If JOB = 'E', the diagonal blocks of A match those of S, but


          the rest of A is unspecified.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max( 1, N ).

B

          B is DOUBLE PRECISION array, dimension (LDB, N)


          On entry, the N-by-N upper triangular matrix B.


          On exit, if JOB = 'S', B contains the upper triangular


          matrix P from the generalized Schur factorization;


          2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks of S


          are reduced to positive diagonal form, i.e., if A(j+1,j) is


          non-zero, then B(j+1,j) = B(j,j+1) = 0, B(j,j) > 0, and


          B(j+1,j+1) > 0.


          If JOB = 'E', the diagonal blocks of B match those of P, but


          the rest of B is unspecified.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max( 1, N ).

ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (N)


          The real parts of each scalar alpha defining an eigenvalue


          of GNEP.

ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (N)


          The imaginary parts of each scalar alpha defining an


          eigenvalue of GNEP.


          If ALPHAI(j) is zero, then the j-th eigenvalue is real; if


          positive, then the j-th and (j+1)-st eigenvalues are a


          complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).

BETA

          BETA is DOUBLE PRECISION array, dimension (N)


          The scalars beta that define the eigenvalues of GNEP.


          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and


          beta = BETA(j) represent the j-th eigenvalue of the matrix


          pair (A,B), in one of the forms lambda = alpha/beta or


          mu = beta/alpha.  Since either lambda or mu may overflow,


          they should not, in general, be computed.

Q

          Q is DOUBLE PRECISION array, dimension (LDQ, N)


          On entry, if COMPQ = 'V', the orthogonal matrix Q1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPQ = 'I', the orthogonal matrix of left Schur


          vectors of (A,B), and if COMPQ = 'V', the orthogonal matrix


          of left Schur vectors of (A,B).


          Not referenced if COMPQ = 'N'.

LDQ

          LDQ is INTEGER


          The leading dimension of the array Q.  LDQ >= 1.


          If COMPQ='V' or 'I', then LDQ >= N.

Z

          Z is DOUBLE PRECISION array, dimension (LDZ, N)


          On entry, if COMPZ = 'V', the orthogonal matrix Z1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPZ = 'I', the orthogonal matrix of


          right Schur vectors of (H,T), and if COMPZ = 'V', the


          orthogonal matrix of right Schur vectors of (A,B).


          Not referenced if COMPZ = 'N'.

LDZ

          LDZ is INTEGER


          The leading dimension of the array Z.  LDZ >= 1.


          If COMPZ='V' or 'I', then LDZ >= N.

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

REC

          REC is INTEGER


             REC indicates the current recursion level. Should be set


             to 0 on first call.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value


          = 1,...,N: the QZ iteration did not converge.  (A,B) is not


                     in Schur form, but ALPHAR(i), ALPHAI(i), and


                     BETA(i), i=INFO+1,...,N should be correct.

Thijs Steel, KU Leuven

May 2020

      Given a 3-by-3 matrix pencil (A,B), DLAQZ1 sets v to a


      scalar multiple of the first column of the product


      (*)  K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1).


      It is assumed that either


              1) sr1 = sr2


          or


              2) si = 0.


      This is useful for starting double implicit shift bulges


      in the QZ algorithm.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


              The 3-by-3 matrix A in (*).

LDA

          LDA is INTEGER


              The leading dimension of A as declared in


              the calling procedure.

B

          B is DOUBLE PRECISION array, dimension (LDB,N)


              The 3-by-3 matrix B in (*).

LDB

          LDB is INTEGER


              The leading dimension of B as declared in


              the calling procedure.

SR1

          SR1 is DOUBLE PRECISION

SR2

          SR2 is DOUBLE PRECISION

SI

          SI is DOUBLE PRECISION

BETA1

          BETA1 is DOUBLE PRECISION

BETA2

          BETA2 is DOUBLE PRECISION

V

          V is DOUBLE PRECISION array, dimension (N)


              A scalar multiple of the first column of the


              matrix K in (*).

Thijs Steel, KU Leuven

May 2020

      DLAQZ2 chases a 2x2 shift bulge in a matrix pencil down a single position

ILQ

          ILQ is LOGICAL


              Determines whether or not to update the matrix Q

ILZ

          ILZ is LOGICAL


              Determines whether or not to update the matrix Z

K

          K is INTEGER


              Index indicating the position of the bulge.


              On entry, the bulge is located in


              (A(k+1:k+2,k:k+1),B(k+1:k+2,k:k+1)).


              On exit, the bulge is located in


              (A(k+2:k+3,k+1:k+2),B(k+2:k+3,k+1:k+2)).

ISTARTM

          ISTARTM is INTEGER

ISTOPM

          ISTOPM is INTEGER


              Updates to (A,B) are restricted to


              (istartm:k+3,k:istopm). It is assumed


              without checking that istartm <= k+1 and


              k+2 <= istopm

IHI

          IHI is INTEGER

A

          A is DOUBLE PRECISION array, dimension (LDA,N)

LDA

          LDA is INTEGER


              The leading dimension of A as declared in


              the calling procedure.

B

          B is DOUBLE PRECISION array, dimension (LDB,N)

LDB

          LDB is INTEGER


              The leading dimension of B as declared in


              the calling procedure.

NQ

          NQ is INTEGER


              The order of the matrix Q

QSTART

          QSTART is INTEGER


              Start index of the matrix Q. Rotations are applied


              To columns k+2-qStart:k+4-qStart of Q.

Q

          Q is DOUBLE PRECISION array, dimension (LDQ,NQ)

LDQ

          LDQ is INTEGER


              The leading dimension of Q as declared in


              the calling procedure.

NZ

          NZ is INTEGER


              The order of the matrix Z

ZSTART

          ZSTART is INTEGER


              Start index of the matrix Z. Rotations are applied


              To columns k+1-qStart:k+3-qStart of Z.

Z

          Z is DOUBLE PRECISION array, dimension (LDZ,NZ)

LDZ

          LDZ is INTEGER


              The leading dimension of Q as declared in


              the calling procedure.

Thijs Steel, KU Leuven

May 2020

 DLAQZ3 performs AED

ILSCHUR

          ILSCHUR is LOGICAL


              Determines whether or not to update the full Schur form

ILQ

          ILQ is LOGICAL


              Determines whether or not to update the matrix Q

ILZ

          ILZ is LOGICAL


              Determines whether or not to update the matrix Z

N

          N is INTEGER


          The order of the matrices A, B, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI mark the rows and columns of (A,B) which


          are to be normalized

NW

          NW is INTEGER


          The desired size of the deflation window.

A

          A is DOUBLE PRECISION array, dimension (LDA, N)

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max( 1, N ).

B

          B is DOUBLE PRECISION array, dimension (LDB, N)

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max( 1, N ).

Q

          Q is DOUBLE PRECISION array, dimension (LDQ, N)

LDQ

          LDQ is INTEGER

Z

          Z is DOUBLE PRECISION array, dimension (LDZ, N)

LDZ

          LDZ is INTEGER

NS

          NS is INTEGER


          The number of unconverged eigenvalues available to


          use as shifts.

ND

          ND is INTEGER


          The number of converged eigenvalues found.

ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (N)


          The real parts of each scalar alpha defining an eigenvalue


          of GNEP.

ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (N)


          The imaginary parts of each scalar alpha defining an


          eigenvalue of GNEP.


          If ALPHAI(j) is zero, then the j-th eigenvalue is real; if


          positive, then the j-th and (j+1)-st eigenvalues are a


          complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).

BETA

          BETA is DOUBLE PRECISION array, dimension (N)


          The scalars beta that define the eigenvalues of GNEP.


          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and


          beta = BETA(j) represent the j-th eigenvalue of the matrix


          pair (A,B), in one of the forms lambda = alpha/beta or


          mu = beta/alpha.  Since either lambda or mu may overflow,


          they should not, in general, be computed.

QC

          QC is DOUBLE PRECISION array, dimension (LDQC, NW)

LDQC

          LDQC is INTEGER

ZC

          ZC is DOUBLE PRECISION array, dimension (LDZC, NW)

LDZC

          LDZ is INTEGER

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

REC

          REC is INTEGER


             REC indicates the current recursion level. Should be set


             to 0 on first call.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Thijs Steel, KU Leuven

May 2020

 DLAQZ4 Executes a single multishift QZ sweep

ILSCHUR

          ILSCHUR is LOGICAL


              Determines whether or not to update the full Schur form

ILQ

          ILQ is LOGICAL


              Determines whether or not to update the matrix Q

ILZ

          ILZ is LOGICAL


              Determines whether or not to update the matrix Z

N

          N is INTEGER


          The order of the matrices A, B, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER

NSHIFTS

          NSHIFTS is INTEGER


          The desired number of shifts to use

NBLOCK_DESIRED

          NBLOCK_DESIRED is INTEGER


          The desired size of the computational windows

SR

          SR is DOUBLE PRECISION array. SR contains


          the real parts of the shifts to use.

SI

          SI is DOUBLE PRECISION array. SI contains


          the imaginary parts of the shifts to use.

SS

          SS is DOUBLE PRECISION array. SS contains


          the scale of the shifts to use.

A

          A is DOUBLE PRECISION array, dimension (LDA, N)

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max( 1, N ).

B

          B is DOUBLE PRECISION array, dimension (LDB, N)

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max( 1, N ).

Q

          Q is DOUBLE PRECISION array, dimension (LDQ, N)

LDQ

          LDQ is INTEGER

Z

          Z is DOUBLE PRECISION array, dimension (LDZ, N)

LDZ

          LDZ is INTEGER

QC

          QC is DOUBLE PRECISION array, dimension (LDQC, NBLOCK_DESIRED)

LDQC

          LDQC is INTEGER

ZC

          ZC is DOUBLE PRECISION array, dimension (LDZC, NBLOCK_DESIRED)

LDZC

          LDZ is INTEGER

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Thijs Steel, KU Leuven

May 2020

 DTGEVC computes some or all of the right and/or left eigenvectors of


 a pair of real matrices (S,P), where S is a quasi-triangular matrix


 and P is upper triangular.  Matrix pairs of this type are produced by


 the generalized Schur factorization of a matrix pair (A,B):


    A = Q*S*Z**T,  B = Q*P*Z**T


 as computed by DGGHRD + DHGEQZ.


 The right eigenvector x and the left eigenvector y of (S,P)


 corresponding to an eigenvalue w are defined by:


    S*x = w*P*x,  (y**H)*S = w*(y**H)*P,


 where y**H denotes the conjugate tranpose of y.


 The eigenvalues are not input to this routine, but are computed


 directly from the diagonal blocks of S and P.


 This routine returns the matrices X and/or Y of right and left


 eigenvectors of (S,P), or the products Z*X and/or Q*Y,


 where Z and Q are input matrices.


 If Q and Z are the orthogonal factors from the generalized Schur


 factorization of a matrix pair (A,B), then Z*X and Q*Y


 are the matrices of right and left eigenvectors of (A,B).

SIDE

          SIDE is CHARACTER*1


          = 'R': compute right eigenvectors only;


          = 'L': compute left eigenvectors only;


          = 'B': compute both right and left eigenvectors.

HOWMNY

          HOWMNY is CHARACTER*1


          = 'A': compute all right and/or left eigenvectors;


          = 'B': compute all right and/or left eigenvectors,


                 backtransformed by the matrices in VR and/or VL;


          = 'S': compute selected right and/or left eigenvectors,


                 specified by the logical array SELECT.

SELECT

          SELECT is LOGICAL array, dimension (N)


          If HOWMNY='S', SELECT specifies the eigenvectors to be


          computed.  If w(j) is a real eigenvalue, the corresponding


          real eigenvector is computed if SELECT(j) is .TRUE..


          If w(j) and w(j+1) are the real and imaginary parts of a


          complex eigenvalue, the corresponding complex eigenvector


          is computed if either SELECT(j) or SELECT(j+1) is .TRUE.,


          and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is


          set to .FALSE..


          Not referenced if HOWMNY = 'A' or 'B'.

N

          N is INTEGER


          The order of the matrices S and P.  N >= 0.

S

          S is DOUBLE PRECISION array, dimension (LDS,N)


          The upper quasi-triangular matrix S from a generalized Schur


          factorization, as computed by DHGEQZ.

LDS

          LDS is INTEGER


          The leading dimension of array S.  LDS >= max(1,N).

P

          P is DOUBLE PRECISION array, dimension (LDP,N)


          The upper triangular matrix P from a generalized Schur


          factorization, as computed by DHGEQZ.


          2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks


          of S must be in positive diagonal form.

LDP

          LDP is INTEGER


          The leading dimension of array P.  LDP >= max(1,N).

VL

          VL is DOUBLE PRECISION array, dimension (LDVL,MM)


          On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must


          contain an N-by-N matrix Q (usually the orthogonal matrix Q


          of left Schur vectors returned by DHGEQZ).


          On exit, if SIDE = 'L' or 'B', VL contains:


          if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);


          if HOWMNY = 'B', the matrix Q*Y;


          if HOWMNY = 'S', the left eigenvectors of (S,P) specified by


                      SELECT, stored consecutively in the columns of


                      VL, in the same order as their eigenvalues.


          A complex eigenvector corresponding to a complex eigenvalue


          is stored in two consecutive columns, the first holding the


          real part, and the second the imaginary part.


          Not referenced if SIDE = 'R'.

LDVL

          LDVL is INTEGER


          The leading dimension of array VL.  LDVL >= 1, and if


          SIDE = 'L' or 'B', LDVL >= N.

VR

          VR is DOUBLE PRECISION array, dimension (LDVR,MM)


          On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must


          contain an N-by-N matrix Z (usually the orthogonal matrix Z


          of right Schur vectors returned by DHGEQZ).


          On exit, if SIDE = 'R' or 'B', VR contains:


          if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);


          if HOWMNY = 'B' or 'b', the matrix Z*X;


          if HOWMNY = 'S' or 's', the right eigenvectors of (S,P)


                      specified by SELECT, stored consecutively in the


                      columns of VR, in the same order as their


                      eigenvalues.


          A complex eigenvector corresponding to a complex eigenvalue


          is stored in two consecutive columns, the first holding the


          real part and the second the imaginary part.


          Not referenced if SIDE = 'L'.

LDVR

          LDVR is INTEGER


          The leading dimension of the array VR.  LDVR >= 1, and if


          SIDE = 'R' or 'B', LDVR >= N.

MM

          MM is INTEGER


          The number of columns in the arrays VL and/or VR. MM >= M.

M

          M is INTEGER


          The number of columns in the arrays VL and/or VR actually


          used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M


          is set to N.  Each selected real eigenvector occupies one


          column and each selected complex eigenvector occupies two


          columns.

WORK

          WORK is DOUBLE PRECISION array, dimension (6*N)

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, the i-th argument had an illegal value.


          > 0:  the 2-by-2 block (INFO:INFO+1) does not have a complex


                eigenvalue.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  Allocation of workspace:


  ---------- -- ---------


     WORK( j ) = 1-norm of j-th column of A, above the diagonal


     WORK( N+j ) = 1-norm of j-th column of B, above the diagonal


     WORK( 2*N+1:3*N ) = real part of eigenvector


     WORK( 3*N+1:4*N ) = imaginary part of eigenvector


     WORK( 4*N+1:5*N ) = real part of back-transformed eigenvector


     WORK( 5*N+1:6*N ) = imaginary part of back-transformed eigenvector


  Rowwise vs. columnwise solution methods:


  ------- --  ---------- -------- -------


  Finding a generalized eigenvector consists basically of solving the


  singular triangular system


   (A - w B) x = 0     (for right) or:   (A - w B)**H y = 0  (for left)


  Consider finding the i-th right eigenvector (assume all eigenvalues


  are real). The equation to be solved is:


       n                   i


  0 = sum  C(j,k) v(k)  = sum  C(j,k) v(k)     for j = i,. . .,1


      k=j                 k=j


  where  C = (A - w B)  (The components v(i+1:n) are 0.)


  The 'rowwise' method is:


  (1)  v(i) := 1


  for j = i-1,. . .,1:


                          i


      (2) compute  s = - sum C(j,k) v(k)   and


                        k=j+1


      (3) v(j) := s / C(j,j)


  Step 2 is sometimes called the 'dot product' step, since it is an


  inner product between the j-th row and the portion of the eigenvector


  that has been computed so far.


  The 'columnwise' method consists basically in doing the sums


  for all the rows in parallel.  As each v(j) is computed, the


  contribution of v(j) times the j-th column of C is added to the


  partial sums.  Since FORTRAN arrays are stored columnwise, this has


  the advantage that at each step, the elements of C that are accessed


  are adjacent to one another, whereas with the rowwise method, the


  elements accessed at a step are spaced LDS (and LDP) words apart.


  When finding left eigenvectors, the matrix in question is the


  transpose of the one in storage, so the rowwise method then


  actually accesses columns of A and B at each step, and so is the


  preferred method.

 DTGEXC reorders the generalized real Schur decomposition of a real


 matrix pair (A,B) using an orthogonal equivalence transformation


                (A, B) = Q * (A, B) * Z**T,


 so that the diagonal block of (A, B) with row index IFST is moved


 to row ILST.


 (A, B) must be in generalized real Schur canonical form (as returned


 by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2


 diagonal blocks. B is upper triangular.


 Optionally, the matrices Q and Z of generalized Schur vectors are


 updated.


        Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T


        Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T

WANTQ

          WANTQ is LOGICAL


          .TRUE. : update the left transformation matrix Q;


          .FALSE.: do not update Q.

WANTZ

          WANTZ is LOGICAL


          .TRUE. : update the right transformation matrix Z;


          .FALSE.: do not update Z.

N

          N is INTEGER


          The order of the matrices A and B. N >= 0.

A

          A is DOUBLE PRECISION array, dimension (LDA,N)


          On entry, the matrix A in generalized real Schur canonical


          form.


          On exit, the updated matrix A, again in generalized


          real Schur canonical form.

LDA

          LDA is INTEGER


          The leading dimension of the array A. LDA >= max(1,N).

B

          B is DOUBLE PRECISION array, dimension (LDB,N)


          On entry, the matrix B in generalized real Schur canonical


          form (A,B).


          On exit, the updated matrix B, again in generalized


          real Schur canonical form (A,B).

LDB

          LDB is INTEGER


          The leading dimension of the array B. LDB >= max(1,N).

Q

          Q is DOUBLE PRECISION array, dimension (LDQ,N)


          On entry, if WANTQ = .TRUE., the orthogonal matrix Q.


          On exit, the updated matrix Q.


          If WANTQ = .FALSE., Q is not referenced.

LDQ

          LDQ is INTEGER


          The leading dimension of the array Q. LDQ >= 1.


          If WANTQ = .TRUE., LDQ >= N.

Z

          Z is DOUBLE PRECISION array, dimension (LDZ,N)


          On entry, if WANTZ = .TRUE., the orthogonal matrix Z.


          On exit, the updated matrix Z.


          If WANTZ = .FALSE., Z is not referenced.

LDZ

          LDZ is INTEGER


          The leading dimension of the array Z. LDZ >= 1.


          If WANTZ = .TRUE., LDZ >= N.

IFST

          IFST is INTEGER

ILST

          ILST is INTEGER


          Specify the reordering of the diagonal blocks of (A, B).


          The block with row index IFST is moved to row ILST, by a


          sequence of swapping between adjacent blocks.


          On exit, if IFST pointed on entry to the second row of


          a 2-by-2 block, it is changed to point to the first row;


          ILST always points to the first row of the block in its


          final position (which may differ from its input value by


          +1 or -1). 1 <= IFST, ILST <= N.

WORK

          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.


          LWORK >= 1 when N <= 1, otherwise LWORK >= 4*N + 16.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


           =0:  successful exit.


           <0:  if INFO = -i, the i-th argument had an illegal value.


           =1:  The transformed matrix pair (A, B) would be too far


                from generalized Schur form; the problem is ill-


                conditioned. (A, B) may have been partially reordered,


                and ILST points to the first row of the current


                position of the block being moved.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

  [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the


      Generalized Real Schur Form of a Regular Matrix Pair (A, B), in


      M.S. Moonen et al (eds), Linear Algebra for Large Scale and


      Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.

 DGELQT computes a blocked LQ factorization of a real M-by-N matrix A


 using the compact WY representation of Q.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

MB

          MB is INTEGER


          The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1.

A

          A is REAL array, dimension (LDA,N)


          On entry, the M-by-N matrix A.


          On exit, the elements on and below the diagonal of the array


          contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is


          lower triangular if M <= N); the elements above the diagonal


          are the rows of V.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is REAL array, dimension (LDT,MIN(M,N))


          The upper triangular block reflectors stored in compact form


          as a sequence of upper triangular blocks.  See below


          for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

WORK

          WORK is REAL array, dimension (MB*N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (         1 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.


  Let K=MIN(M,N).  The number of blocks is B = ceiling(K/MB), where each


  block is of order MB except for the last block, which is of order


  IB = K - (B-1)*MB.  For each of the B blocks, a upper triangular block


  reflector factor is computed: T1, T2, ..., TB.  The MB-by-MB (and IB-by-IB


  for the last block) T's are stored in the MB-by-K matrix T as


               T = (T1 T2 ... TB).

 SGELQT3 recursively computes a LQ factorization of a real M-by-N


 matrix A, using the compact WY representation of Q.


 Based on the algorithm of Elmroth and Gustavson,


 IBM J. Res. Develop. Vol 44 No. 4 July 2000.

M

          M is INTEGER


          The number of rows of the matrix A.  M =< N.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

A

          A is REAL array, dimension (LDA,N)


          On entry, the real M-by-N matrix A.  On exit, the elements on and


          below the diagonal contain the N-by-N lower triangular matrix L; the


          elements above the diagonal are the rows of V.  See below for


          further details.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max(1,M).

T

          T is REAL array, dimension (LDT,N)


          The N-by-N upper triangular factor of the block reflector.


          The elements on and above the diagonal contain the block


          reflector T; the elements below the diagonal are not used.


          See below for further details.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= max(1,N).

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  The matrix V stores the elementary reflectors H(i) in the i-th row


  above the diagonal. For example, if M=5 and N=3, the matrix V is


               V = (  1  v1 v1 v1 v1 )


                   (     1  v2 v2 v2 )


                   (     1  v3 v3 v3 )


  where the vi's represent the vectors which define H(i), which are returned


  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The


  block reflector H is then given by


               H = I - V * T * V**T


  where V**T is the transpose of V.


  For details of the algorithm, see Elmroth and Gustavson (cited above).

 DGEMLQT overwrites the general real M-by-N matrix C with


                 SIDE = 'L'     SIDE = 'R'


 TRANS = 'N':      Q C            C Q


 TRANS = 'T':   Q**T C            C Q**T


 where Q is a real orthogonal matrix defined as the product of K


 elementary reflectors:


       Q = H(1) H(2) . . . H(K) = I - V T V**T


 generated using the compact WY representation as returned by SGELQT.


 Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'.

SIDE

          SIDE is CHARACTER*1


          = 'L': apply Q or Q**T from the Left;


          = 'R': apply Q or Q**T from the Right.

TRANS

          TRANS is CHARACTER*1


          = 'N':  No transpose, apply Q;


          = 'C':  Transpose, apply Q**T.

M

          M is INTEGER


          The number of rows of the matrix C. M >= 0.

N

          N is INTEGER


          The number of columns of the matrix C. N >= 0.

K

          K is INTEGER


          The number of elementary reflectors whose product defines


          the matrix Q.


          If SIDE = 'L', M >= K >= 0;


          if SIDE = 'R', N >= K >= 0.

MB

          MB is INTEGER


          The block size used for the storage of T.  K >= MB >= 1.


          This must be the same value of MB used to generate T


          in SGELQT.

V

          V is REAL array, dimension


                               (LDV,M) if SIDE = 'L',


                               (LDV,N) if SIDE = 'R'


          The i-th row must contain the vector which defines the


          elementary reflector H(i), for i = 1,2,...,k, as returned by


          SGELQT in the first K rows of its array argument A.

LDV

          LDV is INTEGER


          The leading dimension of the array V. LDV >= max(1,K).

T

          T is REAL array, dimension (LDT,K)


          The upper triangular factors of the block reflectors


          as returned by SGELQT, stored as a MB-by-K matrix.

LDT

          LDT is INTEGER


          The leading dimension of the array T.  LDT >= MB.

C

          C is REAL array, dimension (LDC,N)


          On entry, the M-by-N matrix C.


          On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q.

LDC

          LDC is INTEGER


          The leading dimension of the array C. LDC >= max(1,M).

WORK

          WORK is REAL array. The dimension of


          WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SLAQZ0 computes the eigenvalues of a real matrix pair (H,T),


 where H is an upper Hessenberg matrix and T is upper triangular,


 using the double-shift QZ method.


 Matrix pairs of this type are produced by the reduction to


 generalized upper Hessenberg form of a real matrix pair (A,B):


    A = Q1*H*Z1**T,  B = Q1*T*Z1**T,


 as computed by SGGHRD.


 If JOB='S', then the Hessenberg-triangular pair (H,T) is


 also reduced to generalized Schur form,


    H = Q*S*Z**T,  T = Q*P*Z**T,


 where Q and Z are orthogonal matrices, P is an upper triangular


 matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2


 diagonal blocks.


 The 1-by-1 blocks correspond to real eigenvalues of the matrix pair


 (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of


 eigenvalues.


 Additionally, the 2-by-2 upper triangular diagonal blocks of P


 corresponding to 2-by-2 blocks of S are reduced to positive diagonal


 form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0,


 P(j,j) > 0, and P(j+1,j+1) > 0.


 Optionally, the orthogonal matrix Q from the generalized Schur


 factorization may be postmultiplied into an input matrix Q1, and the


 orthogonal matrix Z may be postmultiplied into an input matrix Z1.


 If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced


 the matrix pair (A,B) to generalized upper Hessenberg form, then the


 output matrices Q1*Q and Z1*Z are the orthogonal factors from the


 generalized Schur factorization of (A,B):


    A = (Q1*Q)*S*(Z1*Z)**T,  B = (Q1*Q)*P*(Z1*Z)**T.


 To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently,


 of (A,B)) are computed as a pair of values (alpha,beta), where alpha is


 complex and beta real.


 If beta is nonzero, lambda = alpha / beta is an eigenvalue of the


 generalized nonsymmetric eigenvalue problem (GNEP)


    A*x = lambda*B*x


 and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the


 alternate form of the GNEP


    mu*A*y = B*y.


 Real eigenvalues can be read directly from the generalized Schur


 form:


   alpha = S(i,i), beta = P(i,i).


 Ref: C.B. Moler & G.W. Stewart, 'An Algorithm for Generalized Matrix


      Eigenvalue Problems', SIAM J. Numer. Anal., 10(1973),


      pp. 241--256.


 Ref: B. Kagstrom, D. Kressner, 'Multishift Variants of the QZ


      Algorithm with Aggressive Early Deflation', SIAM J. Numer.


      Anal., 29(2006), pp. 199--227.


 Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril 'A multishift,


      multipole rational QZ method with agressive early deflation'

WANTS

          WANTS is CHARACTER*1


          = 'E': Compute eigenvalues only;


          = 'S': Compute eigenvalues and the Schur form.

WANTQ

          WANTQ is CHARACTER*1


          = 'N': Left Schur vectors (Q) are not computed;


          = 'I': Q is initialized to the unit matrix and the matrix Q


                 of left Schur vectors of (A,B) is returned;


          = 'V': Q must contain an orthogonal matrix Q1 on entry and


                 the product Q1*Q is returned.

WANTZ

          WANTZ is CHARACTER*1


          = 'N': Right Schur vectors (Z) are not computed;


          = 'I': Z is initialized to the unit matrix and the matrix Z


                 of right Schur vectors of (A,B) is returned;


          = 'V': Z must contain an orthogonal matrix Z1 on entry and


                 the product Z1*Z is returned.

N

          N is INTEGER


          The order of the matrices A, B, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI mark the rows and columns of A which are in


          Hessenberg form.  It is assumed that A is already upper


          triangular in rows and columns 1:ILO-1 and IHI+1:N.


          If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0.

A

          A is REAL array, dimension (LDA, N)


          On entry, the N-by-N upper Hessenberg matrix A.


          On exit, if JOB = 'S', A contains the upper quasi-triangular


          matrix S from the generalized Schur factorization.


          If JOB = 'E', the diagonal blocks of A match those of S, but


          the rest of A is unspecified.

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max( 1, N ).

B

          B is REAL array, dimension (LDB, N)


          On entry, the N-by-N upper triangular matrix B.


          On exit, if JOB = 'S', B contains the upper triangular


          matrix P from the generalized Schur factorization;


          2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks of S


          are reduced to positive diagonal form, i.e., if A(j+1,j) is


          non-zero, then B(j+1,j) = B(j,j+1) = 0, B(j,j) > 0, and


          B(j+1,j+1) > 0.


          If JOB = 'E', the diagonal blocks of B match those of P, but


          the rest of B is unspecified.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max( 1, N ).

ALPHAR

          ALPHAR is REAL array, dimension (N)


          The real parts of each scalar alpha defining an eigenvalue


          of GNEP.

ALPHAI

          ALPHAI is REAL array, dimension (N)


          The imaginary parts of each scalar alpha defining an


          eigenvalue of GNEP.


          If ALPHAI(j) is zero, then the j-th eigenvalue is real; if


          positive, then the j-th and (j+1)-st eigenvalues are a


          complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).

BETA

          BETA is REAL array, dimension (N)


          The scalars beta that define the eigenvalues of GNEP.


          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and


          beta = BETA(j) represent the j-th eigenvalue of the matrix


          pair (A,B), in one of the forms lambda = alpha/beta or


          mu = beta/alpha.  Since either lambda or mu may overflow,


          they should not, in general, be computed.

Q

          Q is REAL array, dimension (LDQ, N)


          On entry, if COMPQ = 'V', the orthogonal matrix Q1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPQ = 'I', the orthogonal matrix of left Schur


          vectors of (A,B), and if COMPQ = 'V', the orthogonal matrix


          of left Schur vectors of (A,B).


          Not referenced if COMPQ = 'N'.

LDQ

          LDQ is INTEGER


          The leading dimension of the array Q.  LDQ >= 1.


          If COMPQ='V' or 'I', then LDQ >= N.

Z

          Z is REAL array, dimension (LDZ, N)


          On entry, if COMPZ = 'V', the orthogonal matrix Z1 used in


          the reduction of (A,B) to generalized Hessenberg form.


          On exit, if COMPZ = 'I', the orthogonal matrix of


          right Schur vectors of (H,T), and if COMPZ = 'V', the


          orthogonal matrix of right Schur vectors of (A,B).


          Not referenced if COMPZ = 'N'.

LDZ

          LDZ is INTEGER


          The leading dimension of the array Z.  LDZ >= 1.


          If COMPZ='V' or 'I', then LDZ >= N.

WORK

          WORK is REAL array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

REC

          REC is INTEGER


             REC indicates the current recursion level. Should be set


             to 0 on first call.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value


          = 1,...,N: the QZ iteration did not converge.  (A,B) is not


                     in Schur form, but ALPHAR(i), ALPHAI(i), and


                     BETA(i), i=INFO+1,...,N should be correct.

Thijs Steel, KU Leuven

May 2020

      Given a 3-by-3 matrix pencil (A,B), SLAQZ1 sets v to a


      scalar multiple of the first column of the product


      (*)  K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1).


      It is assumed that either


              1) sr1 = sr2


          or


              2) si = 0.


      This is useful for starting double implicit shift bulges


      in the QZ algorithm.

A

          A is REAL array, dimension (LDA,N)


              The 3-by-3 matrix A in (*).

LDA

          LDA is INTEGER


              The leading dimension of A as declared in


              the calling procedure.

B

          B is REAL array, dimension (LDB,N)


              The 3-by-3 matrix B in (*).

LDB

          LDB is INTEGER


              The leading dimension of B as declared in


              the calling procedure.

SR1

          SR1 is REAL

SR2

          SR2 is REAL

SI

          SI is REAL

BETA1

          BETA1 is REAL

BETA2

          BETA2 is REAL

V

          V is REAL array, dimension (N)


              A scalar multiple of the first column of the


              matrix K in (*).

Thijs Steel, KU Leuven

May 2020

      SLAQZ2 chases a 2x2 shift bulge in a matrix pencil down a single position

ILQ

          ILQ is LOGICAL


              Determines whether or not to update the matrix Q

ILZ

          ILZ is LOGICAL


              Determines whether or not to update the matrix Z

K

          K is INTEGER


              Index indicating the position of the bulge.


              On entry, the bulge is located in


              (A(k+1:k+2,k:k+1),B(k+1:k+2,k:k+1)).


              On exit, the bulge is located in


              (A(k+2:k+3,k+1:k+2),B(k+2:k+3,k+1:k+2)).

ISTARTM

          ISTARTM is INTEGER

ISTOPM

          ISTOPM is INTEGER


              Updates to (A,B) are restricted to


              (istartm:k+3,k:istopm). It is assumed


              without checking that istartm <= k+1 and


              k+2 <= istopm

IHI

          IHI is INTEGER

A

          A is REAL array, dimension (LDA,N)

LDA

          LDA is INTEGER


              The leading dimension of A as declared in


              the calling procedure.

B

          B is REAL array, dimension (LDB,N)

LDB

          LDB is INTEGER


              The leading dimension of B as declared in


              the calling procedure.

NQ

          NQ is INTEGER


              The order of the matrix Q

QSTART

          QSTART is INTEGER


              Start index of the matrix Q. Rotations are applied


              To columns k+2-qStart:k+4-qStart of Q.

Q

          Q is REAL array, dimension (LDQ,NQ)

LDQ

          LDQ is INTEGER


              The leading dimension of Q as declared in


              the calling procedure.

NZ

          NZ is INTEGER


              The order of the matrix Z

ZSTART

          ZSTART is INTEGER


              Start index of the matrix Z. Rotations are applied


              To columns k+1-qStart:k+3-qStart of Z.

Z

          Z is REAL array, dimension (LDZ,NZ)

LDZ

          LDZ is INTEGER


              The leading dimension of Q as declared in


              the calling procedure.

Thijs Steel, KU Leuven

May 2020

 SLAQZ3 performs AED

ILSCHUR

          ILSCHUR is LOGICAL


              Determines whether or not to update the full Schur form

ILQ

          ILQ is LOGICAL


              Determines whether or not to update the matrix Q

ILZ

          ILZ is LOGICAL


              Determines whether or not to update the matrix Z

N

          N is INTEGER


          The order of the matrices A, B, Q, and Z.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI mark the rows and columns of (A,B) which


          are to be normalized

NW

          NW is INTEGER


          The desired size of the deflation window.

A

          A is REAL array, dimension (LDA, N)

LDA

          LDA is INTEGER


          The leading dimension of the array A.  LDA >= max( 1, N ).

B

          B is REAL array, dimension (LDB, N)

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max( 1, N ).

Q

          Q is REAL array, dimension (LDQ, N)

LDQ

          LDQ is INTEGER

Z

          Z is REAL array, dimension (LDZ, N)

LDZ

          LDZ is INTEGER

NS

          NS is INTEGER


          The number of unconverged eigenvalues available to


          use as shifts.

ND

          ND is INTEGER


          The number of converged eigenvalues found.

ALPHAR

          ALPHAR is REAL array, dimension (N)


          The real parts of each scalar alpha defining an eigenvalue


          of GNEP.

ALPHAI

          ALPHAI is REAL array, dimension (N)


          The imaginary parts of each scalar alpha defining an


          eigenvalue of GNEP.


          If ALPHAI(j) is zero, then the j-th eigenvalue is real; if


          positive, then the j-th and (j+1)-st eigenvalues are a


          complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).

BETA

          BETA is REAL array, dimension (N)


          The scalars beta that define the eigenvalues of GNEP.


          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and


          beta = BETA(j) represent the j-th eigenvalue of the matrix


          pair (A,B), in one of the forms lambda = alpha/beta or


          mu = beta/alpha.  Since either lambda or mu may overflow,


          they should not, in general, be computed.

QC

          QC is REAL array, dimension (LDQC, NW)

LDQC

          LDQC is INTEGER

ZC

          ZC is REAL array, dimension (LDZC, NW)

LDZC

          LDZ is INTEGER

WORK

          WORK is REAL array, dimension (MAX(1,LWORK))


          On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK.  LWORK >= max(1,N).


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

REC

          REC is INTEGER


             REC indicates the current recursion level. Should be set


             to 0 on first call.

INFO

          INFO is INTEGER


          = 0: successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Thijs Steel, KU Leuven