nag_zgelqf (f08avc) (PDF version)
f08 Chapter Contents
f08 Chapter Introduction
NAG C Library Manual

NAG Library Function Document

nag_zgelqf (f08avc)

+ Contents

    1  Purpose
    7  Accuracy

1  Purpose

nag_zgelqf (f08avc) computes the LQ factorization of a complex m by n matrix.

2  Specification

#include <nag.h>
#include <nagf08.h>
void  nag_zgelqf (Nag_OrderType order, Integer m, Integer n, Complex a[], Integer pda, Complex tau[], NagError *fail)

3  Description

nag_zgelqf (f08avc) forms the LQ factorization of an arbitrary rectangular complex m by n matrix. No pivoting is performed.
If mn, the factorization is given by:
A = L 0 Q
where L is an m by m lower triangular matrix (with real diagonal elements) and Q is an n by n unitary matrix. It is sometimes more convenient to write the factorization as
A = L 0 Q1 Q2
which reduces to
A = LQ1 ,
where Q1 consists of the first m rows of Q, and Q2 the remaining n-m rows.
If m>n, L is trapezoidal, and the factorization can be written
A = L1 L2 Q
where L1 is lower triangular and L2 is rectangular.
The LQ factorization of A is essentially the same as the QR factorization of AH, since
A = L 0 QAH= QH LH 0 .
The matrix Q is not formed explicitly but is represented as a product of minm,n elementary reflectors (see the f08 Chapter Introduction for details). Functions are provided to work with Q in this representation (see Section 8).
Note also that for any k<m, the information returned in the first k rows of the array a represents an LQ factorization of the first k rows of the original matrix A.

4  References

None.

5  Arguments

1:     orderNag_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:     mIntegerInput
On entry: m, the number of rows of the matrix A.
Constraint: m0.
3:     nIntegerInput
On entry: n, the number of columns of the matrix A.
Constraint: n0.
4:     a[dim]ComplexInput/Output
Note: the dimension, dim, of the array a must be at least
  • max1,pda×n when order=Nag_ColMajor;
  • max1,m×pda when order=Nag_RowMajor.
The i,jth element of the matrix A is stored in
  • a[j-1×pda+i-1] when order=Nag_ColMajor;
  • a[i-1×pda+j-1] when order=Nag_RowMajor.
On entry: the m by n matrix A.
On exit: if mn, the elements above the diagonal are overwritten by details of the unitary matrix Q and the lower triangle is overwritten by the corresponding elements of the m by m lower triangular matrix L.
If m>n, the strictly upper triangular part is overwritten by details of the unitary matrix Q and the remaining elements are overwritten by the corresponding elements of the m by n lower trapezoidal matrix L.
The diagonal elements of L are real.
5:     pdaIntegerInput
On entry: the stride separating row or column elements (depending on the value of order) in the array a.
Constraints:
  • if order=Nag_ColMajor, pdamax1,m;
  • if order=Nag_RowMajor, pdamax1,n.
6:     tau[dim]ComplexOutput
Note: the dimension, dim, of the array tau must be at least max1,minm,n.
On exit: further details of the unitary matrix Q.
7:     failNagError *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_INT
On entry, m=value.
Constraint: m0.
On entry, n=value.
Constraint: n0.
On entry, pda=value.
Constraint: pda>0.
NE_INT_2
On entry, pda=value and m=value.
Constraint: pdamax1,m.
On entry, pda=value and n=value.
Constraint: pdamax1,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 factorization is the exact factorization of a nearby matrix A+E, where
E2 = Oε A2 ,
and ε is the machine precision.

8  Further Comments

The total number of real floating point operations is approximately 83 m2 3n-m  if mn or 83 n2 3m-n  if m>n.
To form the unitary matrix Q nag_zgelqf (f08avc) may be followed by a call to nag_zunglq (f08awc):
nag_zunglq(order,n,n,MIN(m,n),&a,pda,tau,&fail)
but note that the first dimension of the array a, specified by the argument pda, must be at least n, which may be larger than was required by nag_zgelqf (f08avc).
When mn, it is often only the first m rows of Q that are required, and they may be formed by the call:
nag_zunglq(order,m,n,m,&a,pda,tau,&fail)
To apply Q to an arbitrary complex rectangular matrix C, nag_zgelqf (f08avc) may be followed by a call to nag_zunmlq (f08axc). For example,
nag_zunmlq(order,Nag_LeftSide,Nag_ConjTrans,m,p,MIN(m,n),&a,pda,
  tau,&c,pdc,&fail)
forms the matrix product C=QHC, where C is m by p.
The real analogue of this function is nag_dgelqf (f08ahc).

9  Example

This example finds the minimum norm solutions of the under-determined systems of linear equations
Ax1= b1   and   Ax2= b2
where b1 and b2 are the columns of the matrix B,
A = 0.28-0.36i 0.50-0.86i -0.77-0.48i 1.58+0.66i -0.50-1.10i -1.21+0.76i -0.32-0.24i -0.27-1.15i 0.36-0.51i -0.07+1.33i -0.75+0.47i -0.08+1.01i
and
B = -1.35+0.19i 4.83-2.67i 9.41-3.56i -7.28+3.34i -7.57+6.93i 0.62+4.53i .

9.1  Program Text

Program Text (f08avce.c)

9.2  Program Data

Program Data (f08avce.d)

9.3  Program Results

Program Results (f08avce.r)


nag_zgelqf (f08avc) (PDF version)
f08 Chapter Contents
f08 Chapter Introduction
NAG C Library Manual

© The Numerical Algorithms Group Ltd, Oxford, UK. 2012