LAPACK  3.8.0 LAPACK: Linear Algebra PACKage

## ◆ sgemqr()

 subroutine sgemqr ( character SIDE, character TRANS, integer M, integer N, integer K, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) T, integer TSIZE, real, dimension( ldc, * ) C, integer LDC, real, dimension( * ) WORK, integer LWORK, integer INFO )
Purpose:

SGEMQR 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 (SGEQR)

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 REAL array, dimension (LDA,K) Part of the data structure to represent Q as returned by SGEQR.``` [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 REAL array, dimension (MAX(5,TSIZE)). Part of the data structure to represent Q as returned by SGEQR.``` [in] TSIZE ``` TSIZE is INTEGER The dimension of the array T. TSIZE >= 5.``` [in,out] C ``` C is REAL 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) REAL 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```
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 unlikely not 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 SLATSQR or SGEQRT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, SGEQR will use either SLATSQR (if the matrix is tall-and-skinny) or SGEQRT to compute the QR factorization. This version of SGEMQR will use either SLAMTSQR or SGEMQRT to multiply matrix Q by another matrix. Further Details in SLAMTSQR or SGEMQRT.

Definition at line 171 of file sgemqr.f.

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