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

# cunbdb4.f(3)

## NAME

SRC/cunbdb4.f

## SYNOPSIS

### Functions/Subroutines

subroutine **cunbdb4** (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)\
 **CUNBDB4**

## Function/Subroutine Documentation

### subroutine cunbdb4 (integer m, integer p, integer q, complex, dimension(ldx11,\*) x11, integer ldx11, complex, dimension(ldx21,\*) x21, integer ldx21, real, dimension(\*) theta, real, dimension(\*) phi, complex, dimension(\*) taup1, complex, dimension(\*) taup2, complex, dimension(\*) tauq1, complex, dimension(\*) phantom, complex, dimension(\*) work, integer lwork, integer info)

**CUNBDB4**

**Purpose:**

```
!>
!> CUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny
!> matrix X with orthonormal columns:
!>
!>                            [ B11 ]
!>      [ X11 ]   [ P1 |    ] [  0  ]
!>      [-----] = [---------] [-----] Q1**T .
!>      [ X21 ]   [    | P2 ] [ B21 ]
!>                            [  0  ]
!>
!> X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P,
!> M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in
!> which M-Q is not the minimum dimension.
!>
!> The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P),
!> and (M-Q)-by-(M-Q), respectively. They are represented implicitly by
!> Householder vectors.
!>
!> B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented
!> implicitly by angles THETA, PHI.
!>
!>
```

**Parameters**

*M*

```
!>          M is INTEGER
!>           The number of rows X11 plus the number of rows in X21.
!>
```

*P*

```
!>          P is INTEGER
!>           The number of rows in X11. 0 <= P <= M.
!>
```

*Q*

```
!>          Q is INTEGER
!>           The number of columns in X11 and X21. 0 <= Q <= M and
!>           M-Q <= min(P,M-P,Q).
!>
```

*X11*

```
!>          X11 is COMPLEX array, dimension (LDX11,Q)
!>           On entry, the top block of the matrix X to be reduced. On
!>           exit, the columns of tril(X11) specify reflectors for P1 and
!>           the rows of triu(X11,1) specify reflectors for Q1.
!>
```

*LDX11*

```
!>          LDX11 is INTEGER
!>           The leading dimension of X11. LDX11 >= P.
!>
```

*X21*

```
!>          X21 is COMPLEX array, dimension (LDX21,Q)
!>           On entry, the bottom block of the matrix X to be reduced. On
!>           exit, the columns of tril(X21) specify reflectors for P2.
!>
```

*LDX21*

```
!>          LDX21 is INTEGER
!>           The leading dimension of X21. LDX21 >= M-P.
!>
```

*THETA*

```
!>          THETA is REAL array, dimension (Q)
!>           The entries of the bidiagonal blocks B11, B21 are defined by
!>           THETA and PHI. See Further Details.
!>
```

*PHI*

```
!>          PHI is REAL array, dimension (Q-1)
!>           The entries of the bidiagonal blocks B11, B21 are defined by
!>           THETA and PHI. See Further Details.
!>
```

*TAUP1*

```
!>          TAUP1 is COMPLEX array, dimension (M-Q)
!>           The scalar factors of the elementary reflectors that define
!>           P1.
!>
```

*TAUP2*

```
!>          TAUP2 is COMPLEX array, dimension (M-Q)
!>           The scalar factors of the elementary reflectors that define
!>           P2.
!>
```

*TAUQ1*

```
!>          TAUQ1 is COMPLEX array, dimension (Q)
!>           The scalar factors of the elementary reflectors that define
!>           Q1.
!>
```

*PHANTOM*

```
!>          PHANTOM is COMPLEX array, dimension (M)
!>           The routine computes an M-by-1 column vector Y that is
!>           orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and
!>           PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and
!>           Y(P+1:M), respectively.
!>
```

*WORK*

```
!>          WORK is COMPLEX array, dimension (LWORK)
!>
```

*LWORK*

```
!>          LWORK is INTEGER
!>           The dimension of the array WORK. LWORK >= M-Q.
!>
!>           If LWORK = -1, then a workspace query is assumed; the routine
!>           only calculates the optimal size of the WORK array, returns
!>           this value as the first entry of the WORK array, and no error
!>           message related to LWORK is issued by XERBLA.
!>
```

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

**Further Details:**

```
!>
!>  The upper-bidiagonal blocks B11, B21 are represented implicitly by
!>  angles THETA(1), ..., THETA(Q) and PHI(1), ..., PHI(Q-1). Every entry
!>  in each bidiagonal band is a product of a sine or cosine of a THETA
!>  with a sine or cosine of a PHI. See [1] or CUNCSD for details.
!>
!>  P1, P2, and Q1 are represented as products of elementary reflectors.
!>  See CUNCSD2BY1 for details on generating P1, P2, and Q1 using CUNGQR
!>  and CUNGLQ.
!>
```

**References:**

\[1\] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009.

Definition at line **210** of file **cunbdb4.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.