LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ zungqr()

subroutine zungqr ( integer  M,
integer  N,
integer  K,
complex*16, dimension( lda, * )  A,
integer  LDA,
complex*16, dimension( * )  TAU,
complex*16, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

ZUNGQR

Download ZUNGQR + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 ZUNGQR generates an M-by-N complex matrix Q with orthonormal columns,
 which is defined as the first N columns of a product of K elementary
 reflectors of order M

       Q  =  H(1) H(2) . . . H(k)

 as returned by ZGEQRF.
Parameters
[in]M
          M is INTEGER
          The number of rows of the matrix Q. M >= 0.
[in]N
          N is INTEGER
          The number of columns of the matrix Q. M >= N >= 0.
[in]K
          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.
[in,out]A
          A is COMPLEX*16 array, dimension (LDA,N)
          On entry, the i-th column must contain the vector which
          defines the elementary reflector H(i), for i = 1,2,...,k, as
          returned by ZGEQRF in the first k columns of its array
          argument A.
          On exit, the M-by-N matrix Q.
[in]LDA
          LDA is INTEGER
          The first dimension of the array A. LDA >= max(1,M).
[in]TAU
          TAU is COMPLEX*16 array, dimension (K)
          TAU(i) must contain the scalar factor of the elementary
          reflector H(i), as returned by ZGEQRF.
[out]WORK
          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK. LWORK >= max(1,N).
          For optimum performance LWORK >= N*NB, where NB is the
          optimal blocksize.

          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.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument has an illegal value
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 127 of file zungqr.f.

128 *
129 * -- LAPACK computational routine --
130 * -- LAPACK is a software package provided by Univ. of Tennessee, --
131 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
132 *
133 * .. Scalar Arguments ..
134  INTEGER INFO, K, LDA, LWORK, M, N
135 * ..
136 * .. Array Arguments ..
137  COMPLEX*16 A( LDA, * ), TAU( * ), WORK( * )
138 * ..
139 *
140 * =====================================================================
141 *
142 * .. Parameters ..
143  COMPLEX*16 ZERO
144  parameter( zero = ( 0.0d+0, 0.0d+0 ) )
145 * ..
146 * .. Local Scalars ..
147  LOGICAL LQUERY
148  INTEGER I, IB, IINFO, IWS, J, KI, KK, L, LDWORK,
149  $ LWKOPT, NB, NBMIN, NX
150 * ..
151 * .. External Subroutines ..
152  EXTERNAL xerbla, zlarfb, zlarft, zung2r
153 * ..
154 * .. Intrinsic Functions ..
155  INTRINSIC max, min
156 * ..
157 * .. External Functions ..
158  INTEGER ILAENV
159  EXTERNAL ilaenv
160 * ..
161 * .. Executable Statements ..
162 *
163 * Test the input arguments
164 *
165  info = 0
166  nb = ilaenv( 1, 'ZUNGQR', ' ', m, n, k, -1 )
167  lwkopt = max( 1, n )*nb
168  work( 1 ) = lwkopt
169  lquery = ( lwork.EQ.-1 )
170  IF( m.LT.0 ) THEN
171  info = -1
172  ELSE IF( n.LT.0 .OR. n.GT.m ) THEN
173  info = -2
174  ELSE IF( k.LT.0 .OR. k.GT.n ) THEN
175  info = -3
176  ELSE IF( lda.LT.max( 1, m ) ) THEN
177  info = -5
178  ELSE IF( lwork.LT.max( 1, n ) .AND. .NOT.lquery ) THEN
179  info = -8
180  END IF
181  IF( info.NE.0 ) THEN
182  CALL xerbla( 'ZUNGQR', -info )
183  RETURN
184  ELSE IF( lquery ) THEN
185  RETURN
186  END IF
187 *
188 * Quick return if possible
189 *
190  IF( n.LE.0 ) THEN
191  work( 1 ) = 1
192  RETURN
193  END IF
194 *
195  nbmin = 2
196  nx = 0
197  iws = n
198  IF( nb.GT.1 .AND. nb.LT.k ) THEN
199 *
200 * Determine when to cross over from blocked to unblocked code.
201 *
202  nx = max( 0, ilaenv( 3, 'ZUNGQR', ' ', m, n, k, -1 ) )
203  IF( nx.LT.k ) THEN
204 *
205 * Determine if workspace is large enough for blocked code.
206 *
207  ldwork = n
208  iws = ldwork*nb
209  IF( lwork.LT.iws ) THEN
210 *
211 * Not enough workspace to use optimal NB: reduce NB and
212 * determine the minimum value of NB.
213 *
214  nb = lwork / ldwork
215  nbmin = max( 2, ilaenv( 2, 'ZUNGQR', ' ', m, n, k, -1 ) )
216  END IF
217  END IF
218  END IF
219 *
220  IF( nb.GE.nbmin .AND. nb.LT.k .AND. nx.LT.k ) THEN
221 *
222 * Use blocked code after the last block.
223 * The first kk columns are handled by the block method.
224 *
225  ki = ( ( k-nx-1 ) / nb )*nb
226  kk = min( k, ki+nb )
227 *
228 * Set A(1:kk,kk+1:n) to zero.
229 *
230  DO 20 j = kk + 1, n
231  DO 10 i = 1, kk
232  a( i, j ) = zero
233  10 CONTINUE
234  20 CONTINUE
235  ELSE
236  kk = 0
237  END IF
238 *
239 * Use unblocked code for the last or only block.
240 *
241  IF( kk.LT.n )
242  $ CALL zung2r( m-kk, n-kk, k-kk, a( kk+1, kk+1 ), lda,
243  $ tau( kk+1 ), work, iinfo )
244 *
245  IF( kk.GT.0 ) THEN
246 *
247 * Use blocked code
248 *
249  DO 50 i = ki + 1, 1, -nb
250  ib = min( nb, k-i+1 )
251  IF( i+ib.LE.n ) THEN
252 *
253 * Form the triangular factor of the block reflector
254 * H = H(i) H(i+1) . . . H(i+ib-1)
255 *
256  CALL zlarft( 'Forward', 'Columnwise', m-i+1, ib,
257  $ a( i, i ), lda, tau( i ), work, ldwork )
258 *
259 * Apply H to A(i:m,i+ib:n) from the left
260 *
261  CALL zlarfb( 'Left', 'No transpose', 'Forward',
262  $ 'Columnwise', m-i+1, n-i-ib+1, ib,
263  $ a( i, i ), lda, work, ldwork, a( i, i+ib ),
264  $ lda, work( ib+1 ), ldwork )
265  END IF
266 *
267 * Apply H to rows i:m of current block
268 *
269  CALL zung2r( m-i+1, ib, ib, a( i, i ), lda, tau( i ), work,
270  $ iinfo )
271 *
272 * Set rows 1:i-1 of current block to zero
273 *
274  DO 40 j = i, i + ib - 1
275  DO 30 l = 1, i - 1
276  a( l, j ) = zero
277  30 CONTINUE
278  40 CONTINUE
279  50 CONTINUE
280  END IF
281 *
282  work( 1 ) = iws
283  RETURN
284 *
285 * End of ZUNGQR
286 *
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine zlarfb(SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
ZLARFB applies a block reflector or its conjugate-transpose to a general rectangular matrix.
Definition: zlarfb.f:197
subroutine zlarft(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
ZLARFT forms the triangular factor T of a block reflector H = I - vtvH
Definition: zlarft.f:163
subroutine zung2r(M, N, K, A, LDA, TAU, WORK, INFO)
ZUNG2R
Definition: zung2r.f:114
Here is the call graph for this function:
Here is the caller graph for this function: