LAPACK  3.9.0
LAPACK: Linear Algebra PACKage

◆ dgemqr()

subroutine dgemqr ( character  SIDE,
character  TRANS,
integer  M,
integer  N,
integer  K,
double precision, dimension( lda, * )  A,
integer  LDA,
double precision, dimension( * )  T,
integer  TSIZE,
double precision, dimension( ldc, * )  C,
integer  LDC,
double precision, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

DGEMQR

Purpose:
 DGEMQR overwrites the general real M-by-N matrix C with

                      SIDE = 'L'     SIDE = 'R'
      TRANS = 'N':      Q * C          C * Q
      TRANS = 'T':      Q**T * C       C * Q**T

 where Q is a real orthogonal matrix defined as the product
 of blocked elementary reflectors computed by tall skinny
 QR factorization (DGEQR)
Parameters
[in]SIDE
          SIDE is CHARACTER*1
          = 'L': apply Q or Q**T from the Left;
          = 'R': apply Q or Q**T from the Right.
[in]TRANS
          TRANS is CHARACTER*1
          = 'N':  No transpose, apply Q;
          = 'T':  Transpose, apply Q**T.
[in]M
          M is INTEGER
          The number of rows of the matrix A.  M >=0.
[in]N
          N is INTEGER
          The number of columns of the matrix C. N >= 0.
[in]K
          K is INTEGER
          The number of elementary reflectors whose product defines
          the matrix Q.
          If SIDE = 'L', M >= K >= 0;
          if SIDE = 'R', N >= K >= 0.
[in]A
          A is DOUBLE PRECISION array, dimension (LDA,K)
          Part of the data structure to represent Q as returned by DGEQR.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.
          If SIDE = 'L', LDA >= max(1,M);
          if SIDE = 'R', LDA >= max(1,N).
[in]T
          T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE)).
          Part of the data structure to represent Q as returned by DGEQR.
[in]TSIZE
          TSIZE is INTEGER
          The dimension of the array T. TSIZE >= 5.
[in,out]C
          C is DOUBLE PRECISION array, dimension (LDC,N)
          On entry, the M-by-N matrix C.
          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
[in]LDC
          LDC is INTEGER
          The leading dimension of the array C. LDC >= max(1,M).
[out]WORK
         (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK.
          If LWORK = -1, then a workspace query is assumed. The routine
          only calculates the size of the WORK array, returns this
          value as WORK(1), and no error message related to WORK 
          is issued by XERBLA.
[out]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
 These details are particular for this LAPACK implementation. Users should not 
 take them for granted. These details may change in the future, and are not likely
 true for another LAPACK implementation. These details are relevant if one wants
 to try to understand the code. They are not part of the interface.

 In this version,

          T(2): row block size (MB)
          T(3): column block size (NB)
          T(6:TSIZE): data structure needed for Q, computed by
                           DLATSQR or DGEQRT

  Depending on the matrix dimensions M and N, and row and column
  block sizes MB and NB returned by ILAENV, DGEQR will use either
  DLATSQR (if the matrix is tall-and-skinny) or DGEQRT to compute
  the QR factorization.
  This version of DGEMQR will use either DLAMTSQR or DGEMQRT to 
  multiply matrix Q by another matrix.
  Further Details in DLATMSQR or DGEMQRT.

Definition at line 172 of file dgemqr.f.

172 *
173 * -- LAPACK computational routine (version 3.7.0) --
174 * -- LAPACK is a software package provided by Univ. of Tennessee, --
175 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
176 * December 2016
177 *
178 * .. Scalar Arguments ..
179  CHARACTER SIDE, TRANS
180  INTEGER INFO, LDA, M, N, K, TSIZE, LWORK, LDC
181 * ..
182 * .. Array Arguments ..
183  DOUBLE PRECISION A( LDA, * ), T( * ), C( LDC, * ), WORK( * )
184 * ..
185 *
186 * =====================================================================
187 *
188 * ..
189 * .. Local Scalars ..
190  LOGICAL LEFT, RIGHT, TRAN, NOTRAN, LQUERY
191  INTEGER MB, NB, LW, NBLCKS, MN
192 * ..
193 * .. External Functions ..
194  LOGICAL LSAME
195  EXTERNAL lsame
196 * ..
197 * .. External Subroutines ..
198  EXTERNAL dgemqrt, dlamtsqr, xerbla
199 * ..
200 * .. Intrinsic Functions ..
201  INTRINSIC int, max, min, mod
202 * ..
203 * .. Executable Statements ..
204 *
205 * Test the input arguments
206 *
207  lquery = lwork.EQ.-1
208  notran = lsame( trans, 'N' )
209  tran = lsame( trans, 'T' )
210  left = lsame( side, 'L' )
211  right = lsame( side, 'R' )
212 *
213  mb = int( t( 2 ) )
214  nb = int( t( 3 ) )
215  IF( left ) THEN
216  lw = n * nb
217  mn = m
218  ELSE
219  lw = mb * nb
220  mn = n
221  END IF
222 *
223  IF( ( mb.GT.k ) .AND. ( mn.GT.k ) ) THEN
224  IF( mod( mn - k, mb - k ).EQ.0 ) THEN
225  nblcks = ( mn - k ) / ( mb - k )
226  ELSE
227  nblcks = ( mn - k ) / ( mb - k ) + 1
228  END IF
229  ELSE
230  nblcks = 1
231  END IF
232 *
233  info = 0
234  IF( .NOT.left .AND. .NOT.right ) THEN
235  info = -1
236  ELSE IF( .NOT.tran .AND. .NOT.notran ) THEN
237  info = -2
238  ELSE IF( m.LT.0 ) THEN
239  info = -3
240  ELSE IF( n.LT.0 ) THEN
241  info = -4
242  ELSE IF( k.LT.0 .OR. k.GT.mn ) THEN
243  info = -5
244  ELSE IF( lda.LT.max( 1, mn ) ) THEN
245  info = -7
246  ELSE IF( tsize.LT.5 ) THEN
247  info = -9
248  ELSE IF( ldc.LT.max( 1, m ) ) THEN
249  info = -11
250  ELSE IF( ( lwork.LT.max( 1, lw ) ) .AND. ( .NOT.lquery ) ) THEN
251  info = -13
252  END IF
253 *
254  IF( info.EQ.0 ) THEN
255  work( 1 ) = lw
256  END IF
257 *
258  IF( info.NE.0 ) THEN
259  CALL xerbla( 'DGEMQR', -info )
260  RETURN
261  ELSE IF( lquery ) THEN
262  RETURN
263  END IF
264 *
265 * Quick return if possible
266 *
267  IF( min( m, n, k ).EQ.0 ) THEN
268  RETURN
269  END IF
270 *
271  IF( ( left .AND. m.LE.k ) .OR. ( right .AND. n.LE.k )
272  $ .OR. ( mb.LE.k ) .OR. ( mb.GE.max( m, n, k ) ) ) THEN
273  CALL dgemqrt( side, trans, m, n, k, nb, a, lda, t( 6 ),
274  $ nb, c, ldc, work, info )
275  ELSE
276  CALL dlamtsqr( side, trans, m, n, k, mb, nb, a, lda, t( 6 ),
277  $ nb, c, ldc, work, lwork, info )
278  END IF
279 *
280  work( 1 ) = lw
281 *
282  RETURN
283 *
284 * End of DGEMQR
285 *
Here is the call graph for this function:
Here is the caller graph for this function:
dlamtsqr
subroutine dlamtsqr(SIDE, TRANS, M, N, K, MB, NB, A, LDA, T, LDT, C, LDC, WORK, LWORK, INFO)
DLAMTSQR
Definition: dlamtsqr.f:198
dgemqrt
subroutine dgemqrt(SIDE, TRANS, M, N, K, NB, V, LDV, T, LDT, C, LDC, WORK, INFO)
DGEMQRT
Definition: dgemqrt.f:170
xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
lsame
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55