---
name: "slalsa.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/slalsa.f"
---

# slalsa.f(3)

## NAME

SRC/slalsa.f

## SYNOPSIS

### Functions/Subroutines

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.

## Function/Subroutine Documentation

### 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**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.