---
name: "lar1v"
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/lar1v"
---

# lar1v(3)

lar1v: step in larrv, hence stemr & stegr

## NAME

lar1v - lar1v: step in larrv, hence stemr & stegr

## SYNOPSIS

### Functions

subroutine **clar1v** (n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)\
 **CLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.  subroutine **dlar1v** (n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)\
 **DLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.  subroutine **slar1v** (n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)\
 **SLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.  subroutine **zlar1v** (n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)\
 **ZLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.

## Detailed Description

## Function Documentation

### subroutine clar1v (integer n, integer b1, integer bn, real lambda, real, dimension( \* ) d, real, dimension( \* ) l, real, dimension( \* ) ld, real, dimension( \* ) lld, real pivmin, real gaptol, complex, dimension( \* ) z, logical wantnc, integer negcnt, real ztz, real mingma, integer r, integer, dimension( \* ) isuppz, real nrminv, real resid, real rqcorr, real, dimension( \* ) work)

**CLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.

**Purpose:**

```
!>
!> CLAR1V computes the (scaled) r-th column of the inverse of
!> the sumbmatrix in rows B1 through BN of the tridiagonal matrix
!> L D L**T - sigma I. When sigma is close to an eigenvalue, the
!> computed vector is an accurate eigenvector. Usually, r corresponds
!> to the index where the eigenvector is largest in magnitude.
!> The following steps accomplish this computation :
!> (a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,
!> (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
!> (c) Computation of the diagonal elements of the inverse of
!>     L D L**T - sigma I by combining the above transforms, and choosing
!>     r as the index where the diagonal of the inverse is (one of the)
!>     largest in magnitude.
!> (d) Computation of the (scaled) r-th column of the inverse using the
!>     twisted factorization obtained by combining the top part of the
!>     the stationary and the bottom part of the progressive transform.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           The order of the matrix L D L**T.
!>
```

*B1*

```
!>          B1 is INTEGER
!>           First index of the submatrix of L D L**T.
!>
```

*BN*

```
!>          BN is INTEGER
!>           Last index of the submatrix of L D L**T.
!>
```

*LAMBDA*

```
!>          LAMBDA is REAL
!>           The shift. In order to compute an accurate eigenvector,
!>           LAMBDA should be a good approximation to an eigenvalue
!>           of L D L**T.
!>
```

*L*

```
!>          L is REAL array, dimension (N-1)
!>           The (n-1) subdiagonal elements of the unit bidiagonal matrix
!>           L, in elements 1 to N-1.
!>
```

*D*

```
!>          D is REAL array, dimension (N)
!>           The n diagonal elements of the diagonal matrix D.
!>
```

*LD*

```
!>          LD is REAL array, dimension (N-1)
!>           The n-1 elements L(i)*D(i).
!>
```

*LLD*

```
!>          LLD is REAL array, dimension (N-1)
!>           The n-1 elements L(i)*L(i)*D(i).
!>
```

*PIVMIN*

```
!>          PIVMIN is REAL
!>           The minimum pivot in the Sturm sequence.
!>
```

*GAPTOL*

```
!>          GAPTOL is REAL
!>           Tolerance that indicates when eigenvector entries are negligible
!>           w.r.t. their contribution to the residual.
!>
```

*Z*

```
!>          Z is COMPLEX array, dimension (N)
!>           On input, all entries of Z must be set to 0.
!>           On output, Z contains the (scaled) r-th column of the
!>           inverse. The scaling is such that Z(R) equals 1.
!>
```

*WANTNC*

```
!>          WANTNC is LOGICAL
!>           Specifies whether NEGCNT has to be computed.
!>
```

*NEGCNT*

```
!>          NEGCNT is INTEGER
!>           If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
!>           in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise.
!>
```

*ZTZ*

```
!>          ZTZ is REAL
!>           The square of the 2-norm of Z.
!>
```

*MINGMA*

```
!>          MINGMA is REAL
!>           The reciprocal of the largest (in magnitude) diagonal
!>           element of the inverse of L D L**T - sigma I.
!>
```

*R*

```
!>          R is INTEGER
!>           The twist index for the twisted factorization used to
!>           compute Z.
!>           On input, 0 <= R <= N. If R is input as 0, R is set to
!>           the index where (L D L**T - sigma I)^{-1} is largest
!>           in magnitude. If 1 <= R <= N, R is unchanged.
!>           On output, R contains the twist index used to compute Z.
!>           Ideally, R designates the position of the maximum entry in the
!>           eigenvector.
!>
```

*ISUPPZ*

```
!>          ISUPPZ is INTEGER array, dimension (2)
!>           The support of the vector in Z, i.e., the vector Z is
!>           nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
!>
```

*NRMINV*

```
!>          NRMINV is REAL
!>           NRMINV = 1/SQRT( ZTZ )
!>
```

*RESID*

```
!>          RESID is REAL
!>           The residual of the FP vector.
!>           RESID = ABS( MINGMA )/SQRT( ZTZ )
!>
```

*RQCORR*

```
!>          RQCORR is REAL
!>           The Rayleigh Quotient correction to LAMBDA.
!>           RQCORR = MINGMA*TMP
!>
```

*WORK*

```
!>          WORK is REAL array, dimension (4*N)
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Beresford Parlett, University of California, Berkeley, USA \
 Jim Demmel, University of California, Berkeley, USA \
 Inderjit Dhillon, University of Texas, Austin, USA \
 Osni Marques, LBNL/NERSC, USA \
 Christof Voemel, University of California, Berkeley, USA

Definition at line **227** of file **clar1v.f**.

### subroutine dlar1v (integer n, integer b1, integer bn, double precision lambda, double precision, dimension( \* ) d, double precision, dimension( \* ) l, double precision, dimension( \* ) ld, double precision, dimension( \* ) lld, double precision pivmin, double precision gaptol, double precision, dimension( \* ) z, logical wantnc, integer negcnt, double precision ztz, double precision mingma, integer r, integer, dimension( \* ) isuppz, double precision nrminv, double precision resid, double precision rqcorr, double precision, dimension( \* ) work)

**DLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.

**Purpose:**

```
!>
!> DLAR1V computes the (scaled) r-th column of the inverse of
!> the sumbmatrix in rows B1 through BN of the tridiagonal matrix
!> L D L**T - sigma I. When sigma is close to an eigenvalue, the
!> computed vector is an accurate eigenvector. Usually, r corresponds
!> to the index where the eigenvector is largest in magnitude.
!> The following steps accomplish this computation :
!> (a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,
!> (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
!> (c) Computation of the diagonal elements of the inverse of
!>     L D L**T - sigma I by combining the above transforms, and choosing
!>     r as the index where the diagonal of the inverse is (one of the)
!>     largest in magnitude.
!> (d) Computation of the (scaled) r-th column of the inverse using the
!>     twisted factorization obtained by combining the top part of the
!>     the stationary and the bottom part of the progressive transform.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           The order of the matrix L D L**T.
!>
```

*B1*

```
!>          B1 is INTEGER
!>           First index of the submatrix of L D L**T.
!>
```

*BN*

```
!>          BN is INTEGER
!>           Last index of the submatrix of L D L**T.
!>
```

*LAMBDA*

```
!>          LAMBDA is DOUBLE PRECISION
!>           The shift. In order to compute an accurate eigenvector,
!>           LAMBDA should be a good approximation to an eigenvalue
!>           of L D L**T.
!>
```

*L*

```
!>          L is DOUBLE PRECISION array, dimension (N-1)
!>           The (n-1) subdiagonal elements of the unit bidiagonal matrix
!>           L, in elements 1 to N-1.
!>
```

*D*

```
!>          D is DOUBLE PRECISION array, dimension (N)
!>           The n diagonal elements of the diagonal matrix D.
!>
```

*LD*

```
!>          LD is DOUBLE PRECISION array, dimension (N-1)
!>           The n-1 elements L(i)*D(i).
!>
```

*LLD*

```
!>          LLD is DOUBLE PRECISION array, dimension (N-1)
!>           The n-1 elements L(i)*L(i)*D(i).
!>
```

*PIVMIN*

```
!>          PIVMIN is DOUBLE PRECISION
!>           The minimum pivot in the Sturm sequence.
!>
```

*GAPTOL*

```
!>          GAPTOL is DOUBLE PRECISION
!>           Tolerance that indicates when eigenvector entries are negligible
!>           w.r.t. their contribution to the residual.
!>
```

*Z*

```
!>          Z is DOUBLE PRECISION array, dimension (N)
!>           On input, all entries of Z must be set to 0.
!>           On output, Z contains the (scaled) r-th column of the
!>           inverse. The scaling is such that Z(R) equals 1.
!>
```

*WANTNC*

```
!>          WANTNC is LOGICAL
!>           Specifies whether NEGCNT has to be computed.
!>
```

*NEGCNT*

```
!>          NEGCNT is INTEGER
!>           If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
!>           in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise.
!>
```

*ZTZ*

```
!>          ZTZ is DOUBLE PRECISION
!>           The square of the 2-norm of Z.
!>
```

*MINGMA*

```
!>          MINGMA is DOUBLE PRECISION
!>           The reciprocal of the largest (in magnitude) diagonal
!>           element of the inverse of L D L**T - sigma I.
!>
```

*R*

```
!>          R is INTEGER
!>           The twist index for the twisted factorization used to
!>           compute Z.
!>           On input, 0 <= R <= N. If R is input as 0, R is set to
!>           the index where (L D L**T - sigma I)^{-1} is largest
!>           in magnitude. If 1 <= R <= N, R is unchanged.
!>           On output, R contains the twist index used to compute Z.
!>           Ideally, R designates the position of the maximum entry in the
!>           eigenvector.
!>
```

*ISUPPZ*

```
!>          ISUPPZ is INTEGER array, dimension (2)
!>           The support of the vector in Z, i.e., the vector Z is
!>           nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
!>
```

*NRMINV*

```
!>          NRMINV is DOUBLE PRECISION
!>           NRMINV = 1/SQRT( ZTZ )
!>
```

*RESID*

```
!>          RESID is DOUBLE PRECISION
!>           The residual of the FP vector.
!>           RESID = ABS( MINGMA )/SQRT( ZTZ )
!>
```

*RQCORR*

```
!>          RQCORR is DOUBLE PRECISION
!>           The Rayleigh Quotient correction to LAMBDA.
!>           RQCORR = MINGMA*TMP
!>
```

*WORK*

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

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Beresford Parlett, University of California, Berkeley, USA \
 Jim Demmel, University of California, Berkeley, USA \
 Inderjit Dhillon, University of Texas, Austin, USA \
 Osni Marques, LBNL/NERSC, USA \
 Christof Voemel, University of California, Berkeley, USA

Definition at line **227** of file **dlar1v.f**.

### subroutine slar1v (integer n, integer b1, integer bn, real lambda, real, dimension( \* ) d, real, dimension( \* ) l, real, dimension( \* ) ld, real, dimension( \* ) lld, real pivmin, real gaptol, real, dimension( \* ) z, logical wantnc, integer negcnt, real ztz, real mingma, integer r, integer, dimension( \* ) isuppz, real nrminv, real resid, real rqcorr, real, dimension( \* ) work)

**SLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.

**Purpose:**

```
!>
!> SLAR1V computes the (scaled) r-th column of the inverse of
!> the sumbmatrix in rows B1 through BN of the tridiagonal matrix
!> L D L**T - sigma I. When sigma is close to an eigenvalue, the
!> computed vector is an accurate eigenvector. Usually, r corresponds
!> to the index where the eigenvector is largest in magnitude.
!> The following steps accomplish this computation :
!> (a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,
!> (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
!> (c) Computation of the diagonal elements of the inverse of
!>     L D L**T - sigma I by combining the above transforms, and choosing
!>     r as the index where the diagonal of the inverse is (one of the)
!>     largest in magnitude.
!> (d) Computation of the (scaled) r-th column of the inverse using the
!>     twisted factorization obtained by combining the top part of the
!>     the stationary and the bottom part of the progressive transform.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           The order of the matrix L D L**T.
!>
```

*B1*

```
!>          B1 is INTEGER
!>           First index of the submatrix of L D L**T.
!>
```

*BN*

```
!>          BN is INTEGER
!>           Last index of the submatrix of L D L**T.
!>
```

*LAMBDA*

```
!>          LAMBDA is REAL
!>           The shift. In order to compute an accurate eigenvector,
!>           LAMBDA should be a good approximation to an eigenvalue
!>           of L D L**T.
!>
```

*L*

```
!>          L is REAL array, dimension (N-1)
!>           The (n-1) subdiagonal elements of the unit bidiagonal matrix
!>           L, in elements 1 to N-1.
!>
```

*D*

```
!>          D is REAL array, dimension (N)
!>           The n diagonal elements of the diagonal matrix D.
!>
```

*LD*

```
!>          LD is REAL array, dimension (N-1)
!>           The n-1 elements L(i)*D(i).
!>
```

*LLD*

```
!>          LLD is REAL array, dimension (N-1)
!>           The n-1 elements L(i)*L(i)*D(i).
!>
```

*PIVMIN*

```
!>          PIVMIN is REAL
!>           The minimum pivot in the Sturm sequence.
!>
```

*GAPTOL*

```
!>          GAPTOL is REAL
!>           Tolerance that indicates when eigenvector entries are negligible
!>           w.r.t. their contribution to the residual.
!>
```

*Z*

```
!>          Z is REAL array, dimension (N)
!>           On input, all entries of Z must be set to 0.
!>           On output, Z contains the (scaled) r-th column of the
!>           inverse. The scaling is such that Z(R) equals 1.
!>
```

*WANTNC*

```
!>          WANTNC is LOGICAL
!>           Specifies whether NEGCNT has to be computed.
!>
```

*NEGCNT*

```
!>          NEGCNT is INTEGER
!>           If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
!>           in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise.
!>
```

*ZTZ*

```
!>          ZTZ is REAL
!>           The square of the 2-norm of Z.
!>
```

*MINGMA*

```
!>          MINGMA is REAL
!>           The reciprocal of the largest (in magnitude) diagonal
!>           element of the inverse of L D L**T - sigma I.
!>
```

*R*

```
!>          R is INTEGER
!>           The twist index for the twisted factorization used to
!>           compute Z.
!>           On input, 0 <= R <= N. If R is input as 0, R is set to
!>           the index where (L D L**T - sigma I)^{-1} is largest
!>           in magnitude. If 1 <= R <= N, R is unchanged.
!>           On output, R contains the twist index used to compute Z.
!>           Ideally, R designates the position of the maximum entry in the
!>           eigenvector.
!>
```

*ISUPPZ*

```
!>          ISUPPZ is INTEGER array, dimension (2)
!>           The support of the vector in Z, i.e., the vector Z is
!>           nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
!>
```

*NRMINV*

```
!>          NRMINV is REAL
!>           NRMINV = 1/SQRT( ZTZ )
!>
```

*RESID*

```
!>          RESID is REAL
!>           The residual of the FP vector.
!>           RESID = ABS( MINGMA )/SQRT( ZTZ )
!>
```

*RQCORR*

```
!>          RQCORR is REAL
!>           The Rayleigh Quotient correction to LAMBDA.
!>           RQCORR = MINGMA*TMP
!>
```

*WORK*

```
!>          WORK is REAL array, dimension (4*N)
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Beresford Parlett, University of California, Berkeley, USA \
 Jim Demmel, University of California, Berkeley, USA \
 Inderjit Dhillon, University of Texas, Austin, USA \
 Osni Marques, LBNL/NERSC, USA \
 Christof Voemel, University of California, Berkeley, USA

Definition at line **227** of file **slar1v.f**.

### subroutine zlar1v (integer n, integer b1, integer bn, double precision lambda, double precision, dimension( \* ) d, double precision, dimension( \* ) l, double precision, dimension( \* ) ld, double precision, dimension( \* ) lld, double precision pivmin, double precision gaptol, complex\*16, dimension( \* ) z, logical wantnc, integer negcnt, double precision ztz, double precision mingma, integer r, integer, dimension( \* ) isuppz, double precision nrminv, double precision resid, double precision rqcorr, double precision, dimension( \* ) work)

**ZLAR1V** computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.

**Purpose:**

```
!>
!> ZLAR1V computes the (scaled) r-th column of the inverse of
!> the sumbmatrix in rows B1 through BN of the tridiagonal matrix
!> L D L**T - sigma I. When sigma is close to an eigenvalue, the
!> computed vector is an accurate eigenvector. Usually, r corresponds
!> to the index where the eigenvector is largest in magnitude.
!> The following steps accomplish this computation :
!> (a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,
!> (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
!> (c) Computation of the diagonal elements of the inverse of
!>     L D L**T - sigma I by combining the above transforms, and choosing
!>     r as the index where the diagonal of the inverse is (one of the)
!>     largest in magnitude.
!> (d) Computation of the (scaled) r-th column of the inverse using the
!>     twisted factorization obtained by combining the top part of the
!>     the stationary and the bottom part of the progressive transform.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           The order of the matrix L D L**T.
!>
```

*B1*

```
!>          B1 is INTEGER
!>           First index of the submatrix of L D L**T.
!>
```

*BN*

```
!>          BN is INTEGER
!>           Last index of the submatrix of L D L**T.
!>
```

*LAMBDA*

```
!>          LAMBDA is DOUBLE PRECISION
!>           The shift. In order to compute an accurate eigenvector,
!>           LAMBDA should be a good approximation to an eigenvalue
!>           of L D L**T.
!>
```

*L*

```
!>          L is DOUBLE PRECISION array, dimension (N-1)
!>           The (n-1) subdiagonal elements of the unit bidiagonal matrix
!>           L, in elements 1 to N-1.
!>
```

*D*

```
!>          D is DOUBLE PRECISION array, dimension (N)
!>           The n diagonal elements of the diagonal matrix D.
!>
```

*LD*

```
!>          LD is DOUBLE PRECISION array, dimension (N-1)
!>           The n-1 elements L(i)*D(i).
!>
```

*LLD*

```
!>          LLD is DOUBLE PRECISION array, dimension (N-1)
!>           The n-1 elements L(i)*L(i)*D(i).
!>
```

*PIVMIN*

```
!>          PIVMIN is DOUBLE PRECISION
!>           The minimum pivot in the Sturm sequence.
!>
```

*GAPTOL*

```
!>          GAPTOL is DOUBLE PRECISION
!>           Tolerance that indicates when eigenvector entries are negligible
!>           w.r.t. their contribution to the residual.
!>
```

*Z*

```
!>          Z is COMPLEX*16 array, dimension (N)
!>           On input, all entries of Z must be set to 0.
!>           On output, Z contains the (scaled) r-th column of the
!>           inverse. The scaling is such that Z(R) equals 1.
!>
```

*WANTNC*

```
!>          WANTNC is LOGICAL
!>           Specifies whether NEGCNT has to be computed.
!>
```

*NEGCNT*

```
!>          NEGCNT is INTEGER
!>           If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
!>           in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise.
!>
```

*ZTZ*

```
!>          ZTZ is DOUBLE PRECISION
!>           The square of the 2-norm of Z.
!>
```

*MINGMA*

```
!>          MINGMA is DOUBLE PRECISION
!>           The reciprocal of the largest (in magnitude) diagonal
!>           element of the inverse of L D L**T - sigma I.
!>
```

*R*

```
!>          R is INTEGER
!>           The twist index for the twisted factorization used to
!>           compute Z.
!>           On input, 0 <= R <= N. If R is input as 0, R is set to
!>           the index where (L D L**T - sigma I)^{-1} is largest
!>           in magnitude. If 1 <= R <= N, R is unchanged.
!>           On output, R contains the twist index used to compute Z.
!>           Ideally, R designates the position of the maximum entry in the
!>           eigenvector.
!>
```

*ISUPPZ*

```
!>          ISUPPZ is INTEGER array, dimension (2)
!>           The support of the vector in Z, i.e., the vector Z is
!>           nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
!>
```

*NRMINV*

```
!>          NRMINV is DOUBLE PRECISION
!>           NRMINV = 1/SQRT( ZTZ )
!>
```

*RESID*

```
!>          RESID is DOUBLE PRECISION
!>           The residual of the FP vector.
!>           RESID = ABS( MINGMA )/SQRT( ZTZ )
!>
```

*RQCORR*

```
!>          RQCORR is DOUBLE PRECISION
!>           The Rayleigh Quotient correction to LAMBDA.
!>           RQCORR = MINGMA*TMP
!>
```

*WORK*

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

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Beresford Parlett, University of California, Berkeley, USA \
 Jim Demmel, University of California, Berkeley, USA \
 Inderjit Dhillon, University of Texas, Austin, USA \
 Osni Marques, LBNL/NERSC, USA \
 Christof Voemel, University of California, Berkeley, USA

Definition at line **227** of file **zlar1v.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.