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

# slals0.f(3)

## NAME

SRC/slals0.f

## SYNOPSIS

### Functions/Subroutines

subroutine **slals0** (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info)\
 **SLALS0** applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.

## Function/Subroutine Documentation

### subroutine slals0 (integer icompq, integer nl, integer nr, integer sqre, integer nrhs, real, dimension( ldb, \* ) b, integer ldb, real, dimension( ldbx, \* ) bx, integer ldbx, integer, dimension( \* ) perm, integer givptr, integer, dimension( ldgcol, \* ) givcol, integer ldgcol, real, dimension( ldgnum, \* ) givnum, integer ldgnum, real, dimension( ldgnum, \* ) poles, real, dimension( \* ) difl, real, dimension( ldgnum, \* ) difr, real, dimension( \* ) z, integer k, real c, real s, real, dimension( \* ) work, integer info)

**SLALS0** applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.

**Purpose:**

```
!>
!> SLALS0 applies back the multiplying factors of either the left or the
!> right singular vector matrix of a diagonal matrix appended by a row
!> to the right hand side matrix B in solving the least squares problem
!> using the divide-and-conquer SVD approach.
!>
!> For the left singular vector matrix, three types of orthogonal
!> matrices are involved:
!>
!> (1L) Givens rotations: the number of such rotations is GIVPTR; the
!>      pairs of columns/rows they were applied to are stored in GIVCOL;
!>      and the C- and S-values of these rotations are stored in GIVNUM.
!>
!> (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
!>      row, and for J=2:N, PERM(J)-th row of B is to be moved to the
!>      J-th row.
!>
!> (3L) The left singular vector matrix of the remaining matrix.
!>
!> For the right singular vector matrix, four types of orthogonal
!> matrices are involved:
!>
!> (1R) The right singular vector matrix of the remaining matrix.
!>
!> (2R) If SQRE = 1, one extra Givens rotation to generate the right
!>      null space.
!>
!> (3R) The inverse transformation of (2L).
!>
!> (4R) The inverse transformation of (1L).
!>
```

**Parameters**

*ICOMPQ*

```
!>          ICOMPQ is INTEGER
!>         Specifies whether singular vectors are to be computed in
!>         factored form:
!>         = 0: Left singular vector matrix.
!>         = 1: Right singular vector matrix.
!>
```

*NL*

```
!>          NL is INTEGER
!>         The row dimension of the upper block. NL >= 1.
!>
```

*NR*

```
!>          NR is INTEGER
!>         The row dimension of the lower block. NR >= 1.
!>
```

*SQRE*

```
!>          SQRE is INTEGER
!>         = 0: the lower block is an NR-by-NR square matrix.
!>         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
!>
!>         The bidiagonal matrix has row dimension N = NL + NR + 1,
!>         and column dimension M = N + SQRE.
!>
```

*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. LDB must be at least
!>         max(1,MAX( M, N ) ).
!>
```

*BX*

```
!>          BX is REAL array, dimension ( LDBX, NRHS )
!>
```

*LDBX*

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

*PERM*

```
!>          PERM is INTEGER array, dimension ( N )
!>         The permutations (from deflation and sorting) applied
!>         to the two blocks.
!>
```

*GIVPTR*

```
!>          GIVPTR is INTEGER
!>         The number of Givens rotations which took place in this
!>         subproblem.
!>
```

*GIVCOL*

```
!>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )
!>         Each pair of numbers indicates a pair of rows/columns
!>         involved in a Givens rotation.
!>
```

*LDGCOL*

```
!>          LDGCOL is INTEGER
!>         The leading dimension of GIVCOL, must be at least N.
!>
```

*GIVNUM*

```
!>          GIVNUM is REAL array, dimension ( LDGNUM, 2 )
!>         Each number indicates the C or S value used in the
!>         corresponding Givens rotation.
!>
```

*LDGNUM*

```
!>          LDGNUM is INTEGER
!>         The leading dimension of arrays DIFR, POLES and
!>         GIVNUM, must be at least K.
!>
```

*POLES*

```
!>          POLES is REAL array, dimension ( LDGNUM, 2 )
!>         On entry, POLES(1:K, 1) contains the new singular
!>         values obtained from solving the secular equation, and
!>         POLES(1:K, 2) is an array containing the poles in the secular
!>         equation.
!>
```

*DIFL*

```
!>          DIFL is REAL array, dimension ( K ).
!>         On entry, DIFL(I) is the distance between I-th updated
!>         (undeflated) singular value and the I-th (undeflated) old
!>         singular value.
!>
```

*DIFR*

```
!>          DIFR is REAL array, dimension ( LDGNUM, 2 ).
!>         On entry, DIFR(I, 1) contains the distances between I-th
!>         updated (undeflated) singular value and the I+1-th
!>         (undeflated) old singular value. And DIFR(I, 2) is the
!>         normalizing factor for the I-th right singular vector.
!>
```

*Z*

```
!>          Z is REAL array, dimension ( K )
!>         Contain the components of the deflation-adjusted updating row
!>         vector.
!>
```

*K*

```
!>          K is INTEGER
!>         Contains the dimension of the non-deflated matrix,
!>         This is the order of the related secular equation. 1 <= K <=N.
!>
```

*C*

```
!>          C is REAL
!>         C contains garbage if SQRE =0 and the C-value of a Givens
!>         rotation related to the right null space if SQRE = 1.
!>
```

*S*

```
!>          S is REAL
!>         S contains garbage if SQRE =0 and the S-value of a Givens
!>         rotation related to the right null space if SQRE = 1.
!>
```

*WORK*

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

*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 **265** of file **slals0.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.