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

# lalsa(3)

lalsa: SVD of coefficient matrix, step in gelsd

## NAME

lalsa - lalsa: SVD of coefficient matrix, step in gelsd

## SYNOPSIS

### Functions

subroutine **clalsa** (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)\
 **CLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.  subroutine **dlalsa** (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)\
 **DLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.  subroutine **slalsa** (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)\
 **SLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.  subroutine **zlalsa** (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)\
 **ZLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

## Detailed Description

## Function Documentation

### subroutine clalsa (integer icompq, integer smlsiz, integer n, integer nrhs, complex, dimension( ldb, \* ) b, integer ldb, complex, dimension( ldbx, \* ) bx, integer ldbx, real, dimension( ldu, \* ) u, integer ldu, real, dimension( ldu, \* ) vt, integer, dimension( \* ) k, real, dimension( ldu, \* ) difl, real, dimension( ldu, \* ) difr, real, dimension( ldu, \* ) z, real, dimension( ldu, \* ) poles, integer, dimension( \* ) givptr, integer, dimension( ldgcol, \* ) givcol, integer ldgcol, integer, dimension( ldgcol, \* ) perm, real, dimension( ldu, \* ) givnum, real, dimension( \* ) c, real, dimension( \* ) s, real, dimension( \* ) rwork, integer, dimension( \* ) iwork, integer info)

**CLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

**Purpose:**

```
!>
!> CLALSA is an intermediate step in solving the least squares problem
!> by computing the SVD of the coefficient matrix in compact form (The
!> singular vectors are computed as products of simple orthogonal
!> matrices.).
!>
!> If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector
!> matrix of an upper bidiagonal matrix to the right hand side; and if
!> ICOMPQ = 1, CLALSA applies the right singular vector matrix to the
!> right hand side. The singular vector matrices were generated in
!> compact form by CLALSA.
!>
```

**Parameters**

*ICOMPQ*

```
!>          ICOMPQ is INTEGER
!>         Specifies whether the left or the right singular vector
!>         matrix is involved.
!>         = 0: Left singular vector matrix
!>         = 1: Right singular vector matrix
!>
```

*SMLSIZ*

```
!>          SMLSIZ is INTEGER
!>         The maximum size of the subproblems at the bottom of the
!>         computation tree.
!>
```

*N*

```
!>          N is INTEGER
!>         The row and column dimensions of the upper bidiagonal matrix.
!>
```

*NRHS*

```
!>          NRHS is INTEGER
!>         The number of columns of B and BX. NRHS must be at least 1.
!>
```

*B*

```
!>          B is COMPLEX array, dimension ( LDB, NRHS )
!>         On input, B contains the right hand sides of the least
!>         squares problem in rows 1 through M.
!>         On output, B contains the solution X in rows 1 through N.
!>
```

*LDB*

```
!>          LDB is INTEGER
!>         The leading dimension of B in the calling subprogram.
!>         LDB must be at least max(1,MAX( M, N ) ).
!>
```

*BX*

```
!>          BX is COMPLEX array, dimension ( LDBX, NRHS )
!>         On exit, the result of applying the left or right singular
!>         vector matrix to B.
!>
```

*LDBX*

```
!>          LDBX is INTEGER
!>         The leading dimension of BX.
!>
```

*U*

```
!>          U is REAL array, dimension ( LDU, SMLSIZ ).
!>         On entry, U contains the left singular vector matrices of all
!>         subproblems at the bottom level.
!>
```

*LDU*

```
!>          LDU is INTEGER, LDU = > N.
!>         The leading dimension of arrays U, VT, DIFL, DIFR,
!>         POLES, GIVNUM, and Z.
!>
```

*VT*

```
!>          VT is REAL array, dimension ( LDU, SMLSIZ+1 ).
!>         On entry, VT**H contains the right singular vector matrices of
!>         all subproblems at the bottom level.
!>
```

*K*

```
!>          K is INTEGER array, dimension ( N ).
!>
```

*DIFL*

```
!>          DIFL is REAL array, dimension ( LDU, NLVL ).
!>         where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.
!>
```

*DIFR*

```
!>          DIFR is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
!>         distances between singular values on the I-th level and
!>         singular values on the (I -1)-th level, and DIFR(*, 2 * I)
!>         record the normalizing factors of the right singular vectors
!>         matrices of subproblems on I-th level.
!>
```

*Z*

```
!>          Z is REAL array, dimension ( LDU, NLVL ).
!>         On entry, Z(1, I) contains the components of the deflation-
!>         adjusted updating row vector for subproblems on the I-th
!>         level.
!>
```

*POLES*

```
!>          POLES is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
!>         singular values involved in the secular equations on the I-th
!>         level.
!>
```

*GIVPTR*

```
!>          GIVPTR is INTEGER array, dimension ( N ).
!>         On entry, GIVPTR( I ) records the number of Givens
!>         rotations performed on the I-th problem on the computation
!>         tree.
!>
```

*GIVCOL*

```
!>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
!>         On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
!>         locations of Givens rotations performed on the I-th level on
!>         the computation tree.
!>
```

*LDGCOL*

```
!>          LDGCOL is INTEGER, LDGCOL = > N.
!>         The leading dimension of arrays GIVCOL and PERM.
!>
```

*PERM*

```
!>          PERM is INTEGER array, dimension ( LDGCOL, NLVL ).
!>         On entry, PERM(*, I) records permutations done on the I-th
!>         level of the computation tree.
!>
```

*GIVNUM*

```
!>          GIVNUM is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
!>         values of Givens rotations performed on the I-th level on the
!>         computation tree.
!>
```

*C*

```
!>          C is REAL array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         C( I ) contains the C-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*S*

```
!>          S is REAL array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         S( I ) contains the S-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*RWORK*

```
!>          RWORK is REAL array, dimension at least
!>         MAX( (SMLSZ+1)*NRHS*3, N*(1+NRHS) + 2*NRHS ).
!>
```

*IWORK*

```
!>          IWORK is INTEGER array, dimension (3*N)
!>
```

*INFO*

```
!>          INFO is INTEGER
!>          = 0:  successful exit.
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA \
 Osni Marques, LBNL/NERSC, USA \

Definition at line **263** of file **clalsa.f**.

### subroutine dlalsa (integer icompq, integer smlsiz, integer n, integer nrhs, double precision, dimension( ldb, \* ) b, integer ldb, double precision, dimension( ldbx, \* ) bx, integer ldbx, double precision, dimension( ldu, \* ) u, integer ldu, double precision, dimension( ldu, \* ) vt, integer, dimension( \* ) k, double precision, dimension( ldu, \* ) difl, double precision, dimension( ldu, \* ) difr, double precision, dimension( ldu, \* ) z, double precision, dimension( ldu, \* ) poles, integer, dimension( \* ) givptr, integer, dimension( ldgcol, \* ) givcol, integer ldgcol, integer, dimension( ldgcol, \* ) perm, double precision, dimension( ldu, \* ) givnum, double precision, dimension( \* ) c, double precision, dimension( \* ) s, double precision, dimension( \* ) work, integer, dimension( \* ) iwork, integer info)

**DLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

**Purpose:**

```
!>
!> DLALSA is an intermediate step in solving the least squares problem
!> by computing the SVD of the coefficient matrix in compact form (The
!> singular vectors are computed as products of simple orthogonal
!> matrices.).
!>
!> If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector
!> matrix of an upper bidiagonal matrix to the right hand side; and if
!> ICOMPQ = 1, DLALSA applies the right singular vector matrix to the
!> right hand side. The singular vector matrices were generated in
!> compact form by DLALSA.
!>
```

**Parameters**

*ICOMPQ*

```
!>          ICOMPQ is INTEGER
!>         Specifies whether the left or the right singular vector
!>         matrix is involved.
!>         = 0: Left singular vector matrix
!>         = 1: Right singular vector matrix
!>
```

*SMLSIZ*

```
!>          SMLSIZ is INTEGER
!>         The maximum size of the subproblems at the bottom of the
!>         computation tree.
!>
```

*N*

```
!>          N is INTEGER
!>         The row and column dimensions of the upper bidiagonal matrix.
!>
```

*NRHS*

```
!>          NRHS is INTEGER
!>         The number of columns of B and BX. NRHS must be at least 1.
!>
```

*B*

```
!>          B is DOUBLE PRECISION array, dimension ( LDB, NRHS )
!>         On input, B contains the right hand sides of the least
!>         squares problem in rows 1 through M.
!>         On output, B contains the solution X in rows 1 through N.
!>
```

*LDB*

```
!>          LDB is INTEGER
!>         The leading dimension of B in the calling subprogram.
!>         LDB must be at least max(1,MAX( M, N ) ).
!>
```

*BX*

```
!>          BX is DOUBLE PRECISION array, dimension ( LDBX, NRHS )
!>         On exit, the result of applying the left or right singular
!>         vector matrix to B.
!>
```

*LDBX*

```
!>          LDBX is INTEGER
!>         The leading dimension of BX.
!>
```

*U*

```
!>          U is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ).
!>         On entry, U contains the left singular vector matrices of all
!>         subproblems at the bottom level.
!>
```

*LDU*

```
!>          LDU is INTEGER, LDU = > N.
!>         The leading dimension of arrays U, VT, DIFL, DIFR,
!>         POLES, GIVNUM, and Z.
!>
```

*VT*

```
!>          VT is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).
!>         On entry, VT**T contains the right singular vector matrices of
!>         all subproblems at the bottom level.
!>
```

*K*

```
!>          K is INTEGER array, dimension ( N ).
!>
```

*DIFL*

```
!>          DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ).
!>         where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.
!>
```

*DIFR*

```
!>          DIFR is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
!>         distances between singular values on the I-th level and
!>         singular values on the (I -1)-th level, and DIFR(*, 2 * I)
!>         record the normalizing factors of the right singular vectors
!>         matrices of subproblems on I-th level.
!>
```

*Z*

```
!>          Z is DOUBLE PRECISION array, dimension ( LDU, NLVL ).
!>         On entry, Z(1, I) contains the components of the deflation-
!>         adjusted updating row vector for subproblems on the I-th
!>         level.
!>
```

*POLES*

```
!>          POLES is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
!>         singular values involved in the secular equations on the I-th
!>         level.
!>
```

*GIVPTR*

```
!>          GIVPTR is INTEGER array, dimension ( N ).
!>         On entry, GIVPTR( I ) records the number of Givens
!>         rotations performed on the I-th problem on the computation
!>         tree.
!>
```

*GIVCOL*

```
!>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
!>         On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
!>         locations of Givens rotations performed on the I-th level on
!>         the computation tree.
!>
```

*LDGCOL*

```
!>          LDGCOL is INTEGER, LDGCOL = > N.
!>         The leading dimension of arrays GIVCOL and PERM.
!>
```

*PERM*

```
!>          PERM is INTEGER array, dimension ( LDGCOL, NLVL ).
!>         On entry, PERM(*, I) records permutations done on the I-th
!>         level of the computation tree.
!>
```

*GIVNUM*

```
!>          GIVNUM is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
!>         values of Givens rotations performed on the I-th level on the
!>         computation tree.
!>
```

*C*

```
!>          C is DOUBLE PRECISION array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         C( I ) contains the C-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*S*

```
!>          S is DOUBLE PRECISION array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         S( I ) contains the S-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*WORK*

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

*IWORK*

```
!>          IWORK is INTEGER array, dimension (3*N)
!>
```

*INFO*

```
!>          INFO is INTEGER
!>          = 0:  successful exit.
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA \
 Osni Marques, LBNL/NERSC, USA \

Definition at line **263** of file **dlalsa.f**.

### subroutine slalsa (integer icompq, integer smlsiz, integer n, integer nrhs, real, dimension( ldb, \* ) b, integer ldb, real, dimension( ldbx, \* ) bx, integer ldbx, real, dimension( ldu, \* ) u, integer ldu, real, dimension( ldu, \* ) vt, integer, dimension( \* ) k, real, dimension( ldu, \* ) difl, real, dimension( ldu, \* ) difr, real, dimension( ldu, \* ) z, real, dimension( ldu, \* ) poles, integer, dimension( \* ) givptr, integer, dimension( ldgcol, \* ) givcol, integer ldgcol, integer, dimension( ldgcol, \* ) perm, real, dimension( ldu, \* ) givnum, real, dimension( \* ) c, real, dimension( \* ) s, real, dimension( \* ) work, integer, dimension( \* ) iwork, integer info)

**SLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

**Purpose:**

```
!>
!> SLALSA is an intermediate step in solving the least squares problem
!> by computing the SVD of the coefficient matrix in compact form (The
!> singular vectors are computed as products of simple orthogonal
!> matrices.).
!>
!> If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector
!> matrix of an upper bidiagonal matrix to the right hand side; and if
!> ICOMPQ = 1, SLALSA applies the right singular vector matrix to the
!> right hand side. The singular vector matrices were generated in
!> compact form by SLALSA.
!>
```

**Parameters**

*ICOMPQ*

```
!>          ICOMPQ is INTEGER
!>         Specifies whether the left or the right singular vector
!>         matrix is involved.
!>         = 0: Left singular vector matrix
!>         = 1: Right singular vector matrix
!>
```

*SMLSIZ*

```
!>          SMLSIZ is INTEGER
!>         The maximum size of the subproblems at the bottom of the
!>         computation tree.
!>
```

*N*

```
!>          N is INTEGER
!>         The row and column dimensions of the upper bidiagonal matrix.
!>
```

*NRHS*

```
!>          NRHS is INTEGER
!>         The number of columns of B and BX. NRHS must be at least 1.
!>
```

*B*

```
!>          B is REAL array, dimension ( LDB, NRHS )
!>         On input, B contains the right hand sides of the least
!>         squares problem in rows 1 through M.
!>         On output, B contains the solution X in rows 1 through N.
!>
```

*LDB*

```
!>          LDB is INTEGER
!>         The leading dimension of B in the calling subprogram.
!>         LDB must be at least max(1,MAX( M, N ) ).
!>
```

*BX*

```
!>          BX is REAL array, dimension ( LDBX, NRHS )
!>         On exit, the result of applying the left or right singular
!>         vector matrix to B.
!>
```

*LDBX*

```
!>          LDBX is INTEGER
!>         The leading dimension of BX.
!>
```

*U*

```
!>          U is REAL array, dimension ( LDU, SMLSIZ ).
!>         On entry, U contains the left singular vector matrices of all
!>         subproblems at the bottom level.
!>
```

*LDU*

```
!>          LDU is INTEGER, LDU = > N.
!>         The leading dimension of arrays U, VT, DIFL, DIFR,
!>         POLES, GIVNUM, and Z.
!>
```

*VT*

```
!>          VT is REAL array, dimension ( LDU, SMLSIZ+1 ).
!>         On entry, VT**T contains the right singular vector matrices of
!>         all subproblems at the bottom level.
!>
```

*K*

```
!>          K is INTEGER array, dimension ( N ).
!>
```

*DIFL*

```
!>          DIFL is REAL array, dimension ( LDU, NLVL ).
!>         where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.
!>
```

*DIFR*

```
!>          DIFR is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
!>         distances between singular values on the I-th level and
!>         singular values on the (I -1)-th level, and DIFR(*, 2 * I)
!>         record the normalizing factors of the right singular vectors
!>         matrices of subproblems on I-th level.
!>
```

*Z*

```
!>          Z is REAL array, dimension ( LDU, NLVL ).
!>         On entry, Z(1, I) contains the components of the deflation-
!>         adjusted updating row vector for subproblems on the I-th
!>         level.
!>
```

*POLES*

```
!>          POLES is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
!>         singular values involved in the secular equations on the I-th
!>         level.
!>
```

*GIVPTR*

```
!>          GIVPTR is INTEGER array, dimension ( N ).
!>         On entry, GIVPTR( I ) records the number of Givens
!>         rotations performed on the I-th problem on the computation
!>         tree.
!>
```

*GIVCOL*

```
!>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
!>         On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
!>         locations of Givens rotations performed on the I-th level on
!>         the computation tree.
!>
```

*LDGCOL*

```
!>          LDGCOL is INTEGER, LDGCOL = > N.
!>         The leading dimension of arrays GIVCOL and PERM.
!>
```

*PERM*

```
!>          PERM is INTEGER array, dimension ( LDGCOL, NLVL ).
!>         On entry, PERM(*, I) records permutations done on the I-th
!>         level of the computation tree.
!>
```

*GIVNUM*

```
!>          GIVNUM is REAL array, dimension ( LDU, 2 * NLVL ).
!>         On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
!>         values of Givens rotations performed on the I-th level on the
!>         computation tree.
!>
```

*C*

```
!>          C is REAL array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         C( I ) contains the C-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*S*

```
!>          S is REAL array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         S( I ) contains the S-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*WORK*

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

*IWORK*

```
!>          IWORK is INTEGER array, dimension (3*N)
!>
```

*INFO*

```
!>          INFO is INTEGER
!>          = 0:  successful exit.
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA \
 Osni Marques, LBNL/NERSC, USA \

Definition at line **263** of file **slalsa.f**.

### subroutine zlalsa (integer icompq, integer smlsiz, integer n, integer nrhs, complex\*16, dimension( ldb, \* ) b, integer ldb, complex\*16, dimension( ldbx, \* ) bx, integer ldbx, double precision, dimension( ldu, \* ) u, integer ldu, double precision, dimension( ldu, \* ) vt, integer, dimension( \* ) k, double precision, dimension( ldu, \* ) difl, double precision, dimension( ldu, \* ) difr, double precision, dimension( ldu, \* ) z, double precision, dimension( ldu, \* ) poles, integer, dimension( \* ) givptr, integer, dimension( ldgcol, \* ) givcol, integer ldgcol, integer, dimension( ldgcol, \* ) perm, double precision, dimension( ldu, \* ) givnum, double precision, dimension( \* ) c, double precision, dimension( \* ) s, double precision, dimension( \* ) rwork, integer, dimension( \* ) iwork, integer info)

**ZLALSA** computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

**Purpose:**

```
!>
!> ZLALSA is an intermediate step in solving the least squares problem
!> by computing the SVD of the coefficient matrix in compact form (The
!> singular vectors are computed as products of simple orthogonal
!> matrices.).
!>
!> If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector
!> matrix of an upper bidiagonal matrix to the right hand side; and if
!> ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the
!> right hand side. The singular vector matrices were generated in
!> compact form by ZLALSA.
!>
```

**Parameters**

*ICOMPQ*

```
!>          ICOMPQ is INTEGER
!>         Specifies whether the left or the right singular vector
!>         matrix is involved.
!>         = 0: Left singular vector matrix
!>         = 1: Right singular vector matrix
!>
```

*SMLSIZ*

```
!>          SMLSIZ is INTEGER
!>         The maximum size of the subproblems at the bottom of the
!>         computation tree.
!>
```

*N*

```
!>          N is INTEGER
!>         The row and column dimensions of the upper bidiagonal matrix.
!>
```

*NRHS*

```
!>          NRHS is INTEGER
!>         The number of columns of B and BX. NRHS must be at least 1.
!>
```

*B*

```
!>          B is COMPLEX*16 array, dimension ( LDB, NRHS )
!>         On input, B contains the right hand sides of the least
!>         squares problem in rows 1 through M.
!>         On output, B contains the solution X in rows 1 through N.
!>
```

*LDB*

```
!>          LDB is INTEGER
!>         The leading dimension of B in the calling subprogram.
!>         LDB must be at least max(1,MAX( M, N ) ).
!>
```

*BX*

```
!>          BX is COMPLEX*16 array, dimension ( LDBX, NRHS )
!>         On exit, the result of applying the left or right singular
!>         vector matrix to B.
!>
```

*LDBX*

```
!>          LDBX is INTEGER
!>         The leading dimension of BX.
!>
```

*U*

```
!>          U is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ).
!>         On entry, U contains the left singular vector matrices of all
!>         subproblems at the bottom level.
!>
```

*LDU*

```
!>          LDU is INTEGER, LDU = > N.
!>         The leading dimension of arrays U, VT, DIFL, DIFR,
!>         POLES, GIVNUM, and Z.
!>
```

*VT*

```
!>          VT is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).
!>         On entry, VT**H contains the right singular vector matrices of
!>         all subproblems at the bottom level.
!>
```

*K*

```
!>          K is INTEGER array, dimension ( N ).
!>
```

*DIFL*

```
!>          DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ).
!>         where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.
!>
```

*DIFR*

```
!>          DIFR is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
!>         distances between singular values on the I-th level and
!>         singular values on the (I -1)-th level, and DIFR(*, 2 * I)
!>         record the normalizing factors of the right singular vectors
!>         matrices of subproblems on I-th level.
!>
```

*Z*

```
!>          Z is DOUBLE PRECISION array, dimension ( LDU, NLVL ).
!>         On entry, Z(1, I) contains the components of the deflation-
!>         adjusted updating row vector for subproblems on the I-th
!>         level.
!>
```

*POLES*

```
!>          POLES is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
!>         singular values involved in the secular equations on the I-th
!>         level.
!>
```

*GIVPTR*

```
!>          GIVPTR is INTEGER array, dimension ( N ).
!>         On entry, GIVPTR( I ) records the number of Givens
!>         rotations performed on the I-th problem on the computation
!>         tree.
!>
```

*GIVCOL*

```
!>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
!>         On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
!>         locations of Givens rotations performed on the I-th level on
!>         the computation tree.
!>
```

*LDGCOL*

```
!>          LDGCOL is INTEGER, LDGCOL = > N.
!>         The leading dimension of arrays GIVCOL and PERM.
!>
```

*PERM*

```
!>          PERM is INTEGER array, dimension ( LDGCOL, NLVL ).
!>         On entry, PERM(*, I) records permutations done on the I-th
!>         level of the computation tree.
!>
```

*GIVNUM*

```
!>          GIVNUM is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).
!>         On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
!>         values of Givens rotations performed on the I-th level on the
!>         computation tree.
!>
```

*C*

```
!>          C is DOUBLE PRECISION array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         C( I ) contains the C-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*S*

```
!>          S is DOUBLE PRECISION array, dimension ( N ).
!>         On entry, if the I-th subproblem is not square,
!>         S( I ) contains the S-value of a Givens rotation related to
!>         the right null space of the I-th subproblem.
!>
```

*RWORK*

```
!>          RWORK is DOUBLE PRECISION array, dimension at least
!>         MAX( (SMLSZ+1)*NRHS*3, N*(1+NRHS) + 2*NRHS ).
!>
```

*IWORK*

```
!>          IWORK is INTEGER array, dimension (3*N)
!>
```

*INFO*

```
!>          INFO is INTEGER
!>          = 0:  successful exit.
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Contributors:**

Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA \
 Osni Marques, LBNL/NERSC, USA \

Definition at line **263** of file **zlalsa.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.