---
name: "dlatdf.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/dlatdf.f"
---

# dlatdf.f(3)

## NAME

SRC/dlatdf.f

## SYNOPSIS

### Functions/Subroutines

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.

## Function/Subroutine Documentation

### 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.
!>
```

Definition at line **169** of file **dlatdf.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.