NAG Library Function Document

nag_dormbr (f08kgc)

void	nag_dormbr (Nag_OrderType order, Nag_VectType vect, Nag_SideType side, Nag_TransType trans, Integer m, Integer n, Integer k, const double a[], Integer pda, const double tau[], double c[], Integer pdc, NagError *fail)

3 Description

nag_dormbr (f08kgc) is intended to be used after a call to nag_dgebrd (f08kec), which reduces a real rectangular matrix

A

to bidiagonal form

B

by an orthogonal transformation:

A = Q B P^{T}

. nag_dgebrd (f08kec) represents the matrices

Q

and

P^{T}

as products of elementary reflectors.

This function may be used to form one of the matrix products

Q C, Q^{T} C, C Q, C Q^{T}, P C, P^{T} C, C P ​ or ​ C P^{T},

overwriting the result on

C

(which may be any real rectangular matrix).

4 References

Golub G H and Van Loan C F (1996) Matrix Computations (3rd Edition) Johns Hopkins University Press, Baltimore

5 Arguments

Note: in the descriptions below,

r

denotes the order of

Q

P^{T}

: if

side = Nag_LeftSide

r = m

and if

side = Nag_RightSide

r = n

1: order – Nag_OrderTypeInput

On entry: the order argument specifies the two-dimensional storage scheme being used, i.e., row-major ordering or column-major ordering. C language defined storage is specified by

order = Nag_RowMajor

. See Section 3.2.1.3 in the Essential Introduction for a more detailed explanation of the use of this argument.

Constraint:

order = Nag_RowMajor

or Nag_ColMajor.

2: vect – Nag_VectTypeInput

On entry: indicates whether

Q

Q^{T}

P

P^{T}

is to be applied to

C

$vect = Nag_ApplyQ$: $Q$ or $Q^{T}$ is applied to $C$ .
$vect = Nag_ApplyP$: $P$ or $P^{T}$ is applied to $C$ .

Constraint:

vect = Nag_ApplyQ

Nag_ApplyP

3: side – Nag_SideTypeInput

On entry: indicates how

Q

Q^{T}

P

P^{T}

is to be applied to

C

$side = Nag_LeftSide$: $Q$ or $Q^{T}$ or $P$ or $P^{T}$ is applied to $C$ from the left.
$side = Nag_RightSide$: $Q$ or $Q^{T}$ or $P$ or $P^{T}$ is applied to $C$ from the right.

Constraint:

side = Nag_LeftSide

Nag_RightSide

4: trans – Nag_TransTypeInput

On entry: indicates whether

Q

P

Q^{T}

P^{T}

is to be applied to

C

$trans = Nag_NoTrans$: $Q$ or $P$ is applied to $C$ .
$trans = Nag_Trans$: $Q^{T}$ or $P^{T}$ is applied to $C$ .

Constraint:

trans = Nag_NoTrans

Nag_Trans

5: m – IntegerInput

On entry:

m

, the number of rows of the matrix

C

Constraint:

m \geq 0

6: n – IntegerInput

On entry:

n

, the number of columns of the matrix

C

Constraint:

n \geq 0

7: k – IntegerInput

On entry: if

vect = Nag_ApplyQ

, the number of columns in the original matrix

A

vect = Nag_ApplyP

, the number of rows in the original matrix

A

Constraint:

k \geq 0

8: a[ $\dim$ ] – const doubleInput

Note: the dimension, dim, of the array a must be at least

$\max (1, pda \times \min (r, k))$ when $vect = Nag_ApplyQ$ and $order = Nag_ColMajor$ ;
$\max (1, r \times pda)$ when $vect = Nag_ApplyQ$ and $order = Nag_RowMajor$ ;
$\max (1, pda \times r)$ when $vect = Nag_ApplyP$ and $order = Nag_ColMajor$ ;
$\max (1, \min (r, k) \times pda)$ when $vect = Nag_ApplyP$ and $order = Nag_RowMajor$ .

On entry: details of the vectors which define the elementary reflectors, as returned by nag_dgebrd (f08kec).

9: pda – IntegerInput

On entry: the stride separating row or column elements (depending on the value of order) in the array a.

Constraints:

if order=Nag_ColMajor,
- if $vect = Nag_ApplyQ$ , $pda \geq \max (1, r)$ ;
- if $vect = Nag_ApplyP$ , $pda \geq \max (1, \min (r, k))$ ;
if order=Nag_RowMajor,
- if $vect = Nag_ApplyQ$ , $pda \geq \max (1, \min (r, k))$ ;
- if $vect = Nag_ApplyP$ , $pda \geq \max (1, r)$ .

10: tau[ $\dim$ ] – const doubleInput

Note: the dimension, dim, of the array tau must be at least

\max (1, \min (r, k))

On entry: further details of the elementary reflectors, as returned by nag_dgebrd (f08kec) in its argument tauq if

vect = Nag_ApplyQ

, or in its argument taup if

vect = Nag_ApplyP

11: c[ $\dim$ ] – doubleInput/Output

Note: the dimension, dim, of the array c must be at least

$\max (1, pdc \times n)$ when $order = Nag_ColMajor$ ;
$\max (1, m \times pdc)$ when $order = Nag_RowMajor$ .

The

(i, j)

th element of the matrix

C

is stored in

$c [(j - 1) \times pdc + i - 1]$ when $order = Nag_ColMajor$ ;
$c [(i - 1) \times pdc + j - 1]$ when $order = Nag_RowMajor$ .

On entry: the matrix

C

On exit: c is overwritten by

Q C

Q^{T} C

C Q

C^{T} Q

P C

P^{T} C

C P

C^{T} P

as specified by vect, side and trans.

12: pdc – IntegerInput

On entry: the stride separating row or column elements (depending on the value of order) in the array c.

Constraints:

if $order = Nag_ColMajor$ , $pdc \geq \max (1, m)$ ;
if $order = Nag_RowMajor$ , $pdc \geq \max (1, n)$ .

13: fail – NagError *Input/Output

The NAG error argument (see Section 3.6 in the Essential Introduction).

6 Error Indicators and Warnings

NE_ALLOC_FAIL: Dynamic memory allocation failed.
NE_BAD_PARAM: On entry, argument $〈value〉$ had an illegal value.
NE_ENUM_INT_2: On entry, $vect = 〈value〉$ , $pda = 〈value〉$ , $k = 〈value〉$ .
Constraint: if $vect = Nag_ApplyQ$ , $pda \geq \max (1, \min (r, k))$ ;
if $vect = Nag_ApplyP$ , $pda \geq \max (1, r)$ .; On entry, $vect = 〈value〉$ , $pda = 〈value〉$ and $k = 〈value〉$ .
Constraint: if $vect = Nag_ApplyQ$ , $pda \geq \max (1, r)$ ;
if $vect = Nag_ApplyP$ , $pda \geq \max (1, \min (r, k))$ .
NE_INT: On entry, $k = 〈value〉$ .
Constraint: $k \geq 0$ .; On entry, $m = 〈value〉$ .
Constraint: $m \geq 0$ .; On entry, $n = 〈value〉$ .
Constraint: $n \geq 0$ .; On entry, $pda = 〈value〉$ .
Constraint: $pda > 0$ .; On entry, $pdc = 〈value〉$ .
Constraint: $pdc > 0$ .
NE_INT_2: On entry, $pdc = 〈value〉$ and $m = 〈value〉$ .
Constraint: $pdc \geq \max (1, m)$ .; On entry, $pdc = 〈value〉$ and $n = 〈value〉$ .
Constraint: $pdc \geq \max (1, n)$ .
NE_INTERNAL_ERROR: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.

7 Accuracy

The computed result differs from the exact result by a matrix

E

such that

{‖E‖}_{2} = O (ε) {‖C‖}_{2},

where

ε

is the machine precision.

8 Further Comments

The total number of floating point operations is approximately

if $side = Nag_LeftSide$ and $m \geq k$ , $2 n k (2 m - k)$ ;
if $side = Nag_RightSide$ and $n \geq k$ , $2 m k (2 n - k)$ ;
if $side = Nag_LeftSide$ and $m < k$ , $2 m^{2} n$ ;
if $side = Nag_RightSide$ and $n < k$ , $2 m n^{2}$ ,

where

k

is the value of the argument k.

The complex analogue of this function is nag_zunmbr (f08kuc).

9 Example

For this function two examples are presented. Both illustrate how the reduction to bidiagonal form of a matrix

A

may be preceded by a

Q R

L Q

factorization of

A

In the first example,

m > n

, and

A = (\begin{array}{r} - 0.57 & - 1.28 & - 0.39 & 0.25 \\ - 1.93 & 1.08 & - 0.31 & - 2.14 \\ 2.30 & 0.24 & 0.40 & - 0.35 \\ - 1.93 & 0.64 & - 0.66 & 0.08 \\ 0.15 & 0.30 & 0.15 & - 2.13 \\ - 0.02 & 1.03 & - 1.43 & 0.50 \end{array}) .

The function first performs a

Q R

factorization of

A

A = Q_{a} R

and then reduces the factor

R

to bidiagonal form

B

R = Q_{b} B P^{T}

. Finally it forms

Q_{a}

and calls nag_dormbr (f08kgc) to form

Q = Q_{a} Q_{b}

In the second example,

m < n

, and

A = (\begin{array}{r} - 5.42 & 3.28 & - 3.68 & 0.27 & 2.06 & 0.46 \\ - 1.65 & - 3.40 & - 3.20 & - 1.03 & - 4.06 & - 0.01 \\ - 0.37 & 2.35 & 1.90 & 4.31 & - 1.76 & 1.13 \\ - 3.15 & - 0.11 & 1.99 & - 2.70 & 0.26 & 4.50 \end{array}) .

The function first performs an

L Q

factorization of

A

A = L P_{a}^{T}

and then reduces the factor

L

to bidiagonal form

B

L = Q B P_{b}^{T}

. Finally it forms

P_{b}^{T}

and calls nag_dormbr (f08kgc) to form

P^{T} = P_{b}^{T} P_{a}^{T}

NAG Library Function Documentnag_dormbr (f08kgc)

+− Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Further Comments

9 Example

9.1 Program Text

9.2 Program Data

9.3 Program Results

NAG Library Function Document

nag_dormbr (f08kgc)