latdf(3)

NAME
latdf - latdf: Dif-estimate with complete pivoting LU, step in tgsen

SYNOPSIS

  Functions

subroutine clatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
CLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.
subroutine dlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
DLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.
subroutine slatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
SLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.
subroutine zlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
ZLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.

Detailed Description

Function Documentation

  subroutine clatdf (integer ijob, integer n, complex, dimension( ldz, * ) z, integer ldz, complex, dimension( * ) rhs, real rdsum, real rdscal, integer, dimension( * ) ipiv, integer, dimension( * ) jpiv)

CLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.

Purpose:

    !>
    !> CLATDF computes the contribution to the reciprocal Dif-estimate
    !> by solving for x in Z * x = b, where b is chosen such that the norm
    !> of x is as large as possible. It is assumed that LU decomposition
    !> of Z has been computed by CGETC2. On entry RHS = f holds the
    !> contribution from earlier solved sub-systems, and on return RHS = x.
    !>
    !> The factorization of Z returned by CGETC2 has the form
    !> Z = P * L * U * Q, where P and Q are permutation matrices. L is lower
    !> triangular with unit diagonal elements and U is upper triangular.
    !>

Parameters
    IJOB

    !>          IJOB is INTEGER
    !>          IJOB = 2: First compute an approximative null-vector e
    !>              of Z using CGECON, e is normalized and solve for
    !>              Zx = +-e - f with the sign giving the greater value of
    !>              2-norm(x).  About 5 times as expensive as Default.
    !>          IJOB .ne. 2: Local look ahead strategy where
    !>              all entries of the r.h.s. b is chosen as either +1 or
    !>              -1.  Default.
    !>

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix Z.
    !>

    Z

    !>          Z is COMPLEX array, dimension (LDZ, N)
    !>          On entry, the LU part of the factorization of the n-by-n
    !>          matrix Z computed by CGETC2:  Z = P * L * U * Q
    !>

    LDZ

    !>          LDZ is INTEGER
    !>          The leading dimension of the array Z.  LDA >= max(1, N).
    !>

    RHS

    !>          RHS is COMPLEX array, dimension (N).
    !>          On entry, RHS contains contributions from other subsystems.
    !>          On exit, RHS contains the solution of the subsystem with
    !>          entries according to the value of IJOB (see above).
    !>

    RDSUM

    !>          RDSUM is REAL
    !>          On entry, the sum of squares of computed contributions to
    !>          the Dif-estimate under computation by CTGSYL, where the
    !>          scaling factor RDSCAL (see below) has been factored out.
    !>          On exit, the corresponding sum of squares updated with the
    !>          contributions from the current sub-system.
    !>          If TRANS = 'T' RDSUM is not touched.
    !>          NOTE: RDSUM only makes sense when CTGSY2 is called by CTGSYL.
    !>

    RDSCAL

    !>          RDSCAL is REAL
    !>          On entry, scaling factor used to prevent overflow in RDSUM.
    !>          On exit, RDSCAL is updated w.r.t. the current contributions
    !>          in RDSUM.
    !>          If TRANS = 'T', RDSCAL is not touched.
    !>          NOTE: RDSCAL only makes sense when CTGSY2 is called by
    !>          CTGSYL.
    !>

    IPIV

    !>          IPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= i <= N, row i of the
    !>          matrix has been interchanged with row IPIV(i).
    !>

    JPIV

    !>          JPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= j <= N, column j of the
    !>          matrix has been interchanged with column JPIV(j).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:
    This routine is a further developed implementation of algorithm BSOLVE in [1] using complete pivoting in the LU factorization.

Contributors:
    Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

References:
    [1] Bo Kagstrom and Lars Westin, Generalized Schur Methods with Condition Estimators for Solving the Generalized Sylvester Equation, IEEE Transactions on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.

[2] Peter Poromaa, On Efficient and Robust Estimators for the Separation between two Regular Matrix Pairs with Applications in Condition Estimation. Report UMINF-95.05, Department of Computing Science, Umea University, S-901 87 Umea, Sweden, 1995.

  subroutine dlatdf (integer ijob, integer n, double precision, dimension( ldz, * ) z, integer ldz, double precision, dimension( * ) rhs, double precision rdsum, double precision rdscal, integer, dimension( * ) ipiv, integer, dimension( * ) jpiv)

DLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.

Purpose:

    !>
    !> DLATDF uses the LU factorization of the n-by-n matrix Z computed by
    !> DGETC2 and computes a contribution to the reciprocal Dif-estimate
    !> by solving Z * x = b for x, and choosing the r.h.s. b such that
    !> the norm of x is as large as possible. On entry RHS = b holds the
    !> contribution from earlier solved sub-systems, and on return RHS = x.
    !>
    !> The factorization of Z returned by DGETC2 has the form Z = P*L*U*Q,
    !> where P and Q are permutation matrices. L is lower triangular with
    !> unit diagonal elements and U is upper triangular.
    !>

Parameters
    IJOB

    !>          IJOB is INTEGER
    !>          IJOB = 2: First compute an approximative null-vector e
    !>              of Z using DGECON, e is normalized and solve for
    !>              Zx = +-e - f with the sign giving the greater value
    !>              of 2-norm(x). About 5 times as expensive as Default.
    !>          IJOB .ne. 2: Local look ahead strategy where all entries of
    !>              the r.h.s. b is chosen as either +1 or -1 (Default).
    !>

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix Z.
    !>

    Z

    !>          Z is DOUBLE PRECISION array, dimension (LDZ, N)
    !>          On entry, the LU part of the factorization of the n-by-n
    !>          matrix Z computed by DGETC2:  Z = P * L * U * Q
    !>

    LDZ

    !>          LDZ is INTEGER
    !>          The leading dimension of the array Z.  LDA >= max(1, N).
    !>

    RHS

    !>          RHS is DOUBLE PRECISION array, dimension (N)
    !>          On entry, RHS contains contributions from other subsystems.
    !>          On exit, RHS contains the solution of the subsystem with
    !>          entries according to the value of IJOB (see above).
    !>

    RDSUM

    !>          RDSUM is DOUBLE PRECISION
    !>          On entry, the sum of squares of computed contributions to
    !>          the Dif-estimate under computation by DTGSYL, where the
    !>          scaling factor RDSCAL (see below) has been factored out.
    !>          On exit, the corresponding sum of squares updated with the
    !>          contributions from the current sub-system.
    !>          If TRANS = 'T' RDSUM is not touched.
    !>          NOTE: RDSUM only makes sense when DTGSY2 is called by STGSYL.
    !>

    RDSCAL

    !>          RDSCAL is DOUBLE PRECISION
    !>          On entry, scaling factor used to prevent overflow in RDSUM.
    !>          On exit, RDSCAL is updated w.r.t. the current contributions
    !>          in RDSUM.
    !>          If TRANS = 'T', RDSCAL is not touched.
    !>          NOTE: RDSCAL only makes sense when DTGSY2 is called by
    !>                DTGSYL.
    !>

    IPIV

    !>          IPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= i <= N, row i of the
    !>          matrix has been interchanged with row IPIV(i).
    !>

    JPIV

    !>          JPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= j <= N, column j of the
    !>          matrix has been interchanged with column JPIV(j).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:
    This routine is a further developed implementation of algorithm BSOLVE in [1] using complete pivoting in the LU factorization.

Contributors:
    Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

References:

    !>
    !>
    !>  [1] Bo Kagstrom and Lars Westin,
    !>      Generalized Schur Methods with Condition Estimators for
    !>      Solving the Generalized Sylvester Equation, IEEE Transactions
    !>      on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.
    !>
    !>  [2] Peter Poromaa,
    !>      On Efficient and Robust Estimators for the Separation
    !>      between two Regular Matrix Pairs with Applications in
    !>      Condition Estimation. Report IMINF-95.05, Departement of
    !>      Computing Science, Umea University, S-901 87 Umea, Sweden, 1995.
    !>

  subroutine slatdf (integer ijob, integer n, real, dimension( ldz, * ) z, integer ldz, real, dimension( * ) rhs, real rdsum, real rdscal, integer, dimension( * ) ipiv, integer, dimension( * ) jpiv)

SLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.

Purpose:

    !>
    !> SLATDF uses the LU factorization of the n-by-n matrix Z computed by
    !> SGETC2 and computes a contribution to the reciprocal Dif-estimate
    !> by solving Z * x = b for x, and choosing the r.h.s. b such that
    !> the norm of x is as large as possible. On entry RHS = b holds the
    !> contribution from earlier solved sub-systems, and on return RHS = x.
    !>
    !> The factorization of Z returned by SGETC2 has the form Z = P*L*U*Q,
    !> where P and Q are permutation matrices. L is lower triangular with
    !> unit diagonal elements and U is upper triangular.
    !>

Parameters
    IJOB

    !>          IJOB is INTEGER
    !>          IJOB = 2: First compute an approximative null-vector e
    !>              of Z using SGECON, e is normalized and solve for
    !>              Zx = +-e - f with the sign giving the greater value
    !>              of 2-norm(x). About 5 times as expensive as Default.
    !>          IJOB .ne. 2: Local look ahead strategy where all entries of
    !>              the r.h.s. b is chosen as either +1 or -1 (Default).
    !>

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix Z.
    !>

    Z

    !>          Z is REAL array, dimension (LDZ, N)
    !>          On entry, the LU part of the factorization of the n-by-n
    !>          matrix Z computed by SGETC2:  Z = P * L * U * Q
    !>

    LDZ

    !>          LDZ is INTEGER
    !>          The leading dimension of the array Z.  LDA >= max(1, N).
    !>

    RHS

    !>          RHS is REAL array, dimension N.
    !>          On entry, RHS contains contributions from other subsystems.
    !>          On exit, RHS contains the solution of the subsystem with
    !>          entries according to the value of IJOB (see above).
    !>

    RDSUM

    !>          RDSUM is REAL
    !>          On entry, the sum of squares of computed contributions to
    !>          the Dif-estimate under computation by STGSYL, where the
    !>          scaling factor RDSCAL (see below) has been factored out.
    !>          On exit, the corresponding sum of squares updated with the
    !>          contributions from the current sub-system.
    !>          If TRANS = 'T' RDSUM is not touched.
    !>          NOTE: RDSUM only makes sense when STGSY2 is called by STGSYL.
    !>

    RDSCAL

    !>          RDSCAL is REAL
    !>          On entry, scaling factor used to prevent overflow in RDSUM.
    !>          On exit, RDSCAL is updated w.r.t. the current contributions
    !>          in RDSUM.
    !>          If TRANS = 'T', RDSCAL is not touched.
    !>          NOTE: RDSCAL only makes sense when STGSY2 is called by
    !>                STGSYL.
    !>

    IPIV

    !>          IPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= i <= N, row i of the
    !>          matrix has been interchanged with row IPIV(i).
    !>

    JPIV

    !>          JPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= j <= N, column j of the
    !>          matrix has been interchanged with column JPIV(j).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:
    This routine is a further developed implementation of algorithm BSOLVE in [1] using complete pivoting in the LU factorization.

Contributors:
    Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

References:

    !>
    !>
    !>  [1] Bo Kagstrom and Lars Westin,
    !>      Generalized Schur Methods with Condition Estimators for
    !>      Solving the Generalized Sylvester Equation, IEEE Transactions
    !>      on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.
    !>
    !>  [2] Peter Poromaa,
    !>      On Efficient and Robust Estimators for the Separation
    !>      between two Regular Matrix Pairs with Applications in
    !>      Condition Estimation. Report IMINF-95.05, Departement of
    !>      Computing Science, Umea University, S-901 87 Umea, Sweden, 1995.
    !>

  subroutine zlatdf (integer ijob, integer n, complex*16, dimension( ldz, * ) z, integer ldz, complex*16, dimension( * ) rhs, double precision rdsum, double precision rdscal, integer, dimension( * ) ipiv, integer, dimension( * ) jpiv)

ZLATDF uses the LU factorization of the n-by-n matrix computed by sgetc2 and computes a contribution to the reciprocal Dif-estimate.

Purpose:

    !>
    !> ZLATDF computes the contribution to the reciprocal Dif-estimate
    !> by solving for x in Z * x = b, where b is chosen such that the norm
    !> of x is as large as possible. It is assumed that LU decomposition
    !> of Z has been computed by ZGETC2. On entry RHS = f holds the
    !> contribution from earlier solved sub-systems, and on return RHS = x.
    !>
    !> The factorization of Z returned by ZGETC2 has the form
    !> Z = P * L * U * Q, where P and Q are permutation matrices. L is lower
    !> triangular with unit diagonal elements and U is upper triangular.
    !>

Parameters
    IJOB

    !>          IJOB is INTEGER
    !>          IJOB = 2: First compute an approximative null-vector e
    !>              of Z using ZGECON, e is normalized and solve for
    !>              Zx = +-e - f with the sign giving the greater value of
    !>              2-norm(x).  About 5 times as expensive as Default.
    !>          IJOB .ne. 2: Local look ahead strategy where
    !>              all entries of the r.h.s. b is chosen as either +1 or
    !>              -1.  Default.
    !>

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix Z.
    !>

    Z

    !>          Z is COMPLEX*16 array, dimension (LDZ, N)
    !>          On entry, the LU part of the factorization of the n-by-n
    !>          matrix Z computed by ZGETC2:  Z = P * L * U * Q
    !>

    LDZ

    !>          LDZ is INTEGER
    !>          The leading dimension of the array Z.  LDA >= max(1, N).
    !>

    RHS

    !>          RHS is COMPLEX*16 array, dimension (N).
    !>          On entry, RHS contains contributions from other subsystems.
    !>          On exit, RHS contains the solution of the subsystem with
    !>          entries according to the value of IJOB (see above).
    !>

    RDSUM

    !>          RDSUM is DOUBLE PRECISION
    !>          On entry, the sum of squares of computed contributions to
    !>          the Dif-estimate under computation by ZTGSYL, where the
    !>          scaling factor RDSCAL (see below) has been factored out.
    !>          On exit, the corresponding sum of squares updated with the
    !>          contributions from the current sub-system.
    !>          If TRANS = 'T' RDSUM is not touched.
    !>          NOTE: RDSUM only makes sense when ZTGSY2 is called by CTGSYL.
    !>

    RDSCAL

    !>          RDSCAL is DOUBLE PRECISION
    !>          On entry, scaling factor used to prevent overflow in RDSUM.
    !>          On exit, RDSCAL is updated w.r.t. the current contributions
    !>          in RDSUM.
    !>          If TRANS = 'T', RDSCAL is not touched.
    !>          NOTE: RDSCAL only makes sense when ZTGSY2 is called by
    !>          ZTGSYL.
    !>

    IPIV

    !>          IPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= i <= N, row i of the
    !>          matrix has been interchanged with row IPIV(i).
    !>

    JPIV

    !>          JPIV is INTEGER array, dimension (N).
    !>          The pivot indices; for 1 <= j <= N, column j of the
    !>          matrix has been interchanged with column JPIV(j).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:
    This routine is a further developed implementation of algorithm BSOLVE in [1] using complete pivoting in the LU factorization.

Contributors:
    Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

References:
    [1] Bo Kagstrom and Lars Westin, Generalized Schur Methods with Condition Estimators for Solving the Generalized Sylvester Equation, IEEE Transactions on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.
     [2] Peter Poromaa, On Efficient and Robust Estimators for the Separation between two Regular Matrix Pairs with Applications in Condition Estimation. Report UMINF-95.05, Department of Computing Science, Umea University, S-901 87 Umea, Sweden, 1995.

Author

Generated automatically by Doxygen for LAPACK from the source code.