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

# clalsd.f(3)

## NAME

SRC/clalsd.f

## SYNOPSIS

### Functions/Subroutines

subroutine **clalsd** (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)\
 **CLALSD** uses the singular value decomposition of A to solve the least squares problem.

## Function/Subroutine Documentation

### subroutine clalsd (character uplo, integer smlsiz, integer n, integer nrhs, real, dimension( \* ) d, real, dimension( \* ) e, complex, dimension( ldb, \* ) b, integer ldb, real rcond, integer rank, complex, dimension( \* ) work, real, dimension( \* ) rwork, integer, dimension( \* ) iwork, integer info)

**CLALSD** uses the singular value decomposition of A to solve the least squares problem.

**Purpose:**

```
!>
!> CLALSD uses the singular value decomposition of A to solve the least
!> squares problem of finding X to minimize the Euclidean norm of each
!> column of A*X-B, where A is N-by-N upper bidiagonal, and X and B
!> are N-by-NRHS. The solution X overwrites B.
!>
!> The singular values of A smaller than RCOND times the largest
!> singular value are treated as zero in solving the least squares
!> problem; in this case a minimum norm solution is returned.
!> The actual singular values are returned in D in ascending order.
!>
!>
```

**Parameters**

*UPLO*

```
!>          UPLO is CHARACTER*1
!>         = 'U': D and E define an upper bidiagonal matrix.
!>         = 'L': D and E define a  lower bidiagonal matrix.
!>
```

*SMLSIZ*

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

*N*

```
!>          N is INTEGER
!>         The dimension of the  bidiagonal matrix.  N >= 0.
!>
```

*NRHS*

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

*D*

```
!>          D is REAL array, dimension (N)
!>         On entry D contains the main diagonal of the bidiagonal
!>         matrix. On exit, if INFO = 0, D contains its singular values.
!>
```

*E*

```
!>          E is REAL array, dimension (N-1)
!>         Contains the super-diagonal entries of the bidiagonal matrix.
!>         On exit, E has been destroyed.
!>
```

*B*

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

*LDB*

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

*RCOND*

```
!>          RCOND is REAL
!>         The singular values of A less than or equal to RCOND times
!>         the largest singular value are treated as zero in solving
!>         the least squares problem. If RCOND is negative,
!>         machine precision is used instead.
!>         For example, if diag(S)*X=B were the least squares problem,
!>         where diag(S) is a diagonal matrix of singular values, the
!>         solution would be X(i) = B(i) / S(i) if S(i) is greater than
!>         RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to
!>         RCOND*max(S).
!>
```

*RANK*

```
!>          RANK is INTEGER
!>         The number of singular values of A greater than RCOND times
!>         the largest singular value.
!>
```

*WORK*

```
!>          WORK is COMPLEX array, dimension (N * NRHS).
!>
```

*RWORK*

```
!>          RWORK is REAL array, dimension at least
!>         (9*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +
!>         MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS ),
!>         where
!>         NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )
!>
```

*IWORK*

```
!>          IWORK is INTEGER array, dimension (3*N*NLVL + 11*N).
!>
```

*INFO*

```
!>          INFO is INTEGER
!>         = 0:  successful exit.
!>         < 0:  if INFO = -i, the i-th argument had an illegal value.
!>         > 0:  The algorithm failed to compute a singular value while
!>               working on the submatrix lying in rows and columns
!>               INFO/(N+1) through MOD(INFO,N+1).
!>
```

**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 **178** of file **clalsd.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.