LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ sgeqr()

subroutine sgeqr ( integer m,
integer n,
real, dimension( lda, * ) a,
integer lda,
real, dimension( * ) t,
integer tsize,
real, dimension( * ) work,
integer lwork,
integer info )

SGEQR

Purpose:
!>
!> SGEQR computes a QR factorization of a real M-by-N matrix A:
!>
!>    A = Q * ( R ),
!>            ( 0 )
!>
!> where:
!>
!>    Q is a M-by-M orthogonal matrix;
!>    R is an upper-triangular N-by-N matrix;
!>    0 is a (M-N)-by-N zero matrix, if M > N.
!>
!>
Parameters
[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 A.  N >= 0.
!>
[in,out]A
!>          A is REAL array, dimension (LDA,N)
!>          On entry, the M-by-N matrix A.
!>          On exit, the elements on and above the diagonal of the array
!>          contain the min(M,N)-by-N upper trapezoidal matrix R
!>          (R is upper triangular if M >= N);
!>          the elements below the diagonal are used to store part of the 
!>          data structure to represent Q.
!>
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,M).
!>
[out]T
!>          T is REAL array, dimension (MAX(5,TSIZE))
!>          On exit, if INFO = 0, T(1) returns optimal (or either minimal 
!>          or optimal, if query is assumed) TSIZE. See TSIZE for details.
!>          Remaining T contains part of the data structure used to represent Q.
!>          If one wants to apply or construct Q, then one needs to keep T 
!>          (in addition to A) and pass it to further subroutines.
!>
[in]TSIZE
!>          TSIZE is INTEGER
!>          If TSIZE >= 5, the dimension of the array T.
!>          If TSIZE = -1 or -2, then a workspace query is assumed. The routine
!>          only calculates the sizes of the T and WORK arrays, returns these
!>          values as the first entries of the T and WORK arrays, and no error
!>          message related to T or WORK is issued by XERBLA.
!>          If TSIZE = -1, the routine calculates optimal size of T for the 
!>          optimum performance and returns this value in T(1).
!>          If TSIZE = -2, the routine calculates minimal size of T and 
!>          returns this value in T(1).
!>
[out]WORK
!>          (workspace) REAL array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) contains optimal (or either minimal
!>          or optimal, if query was assumed) LWORK.
!>          See LWORK for details.
!>
[in]LWORK
!>          LWORK is INTEGER
!>          The dimension of the array WORK. LWORK >= 1.
!>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
!>          only calculates the sizes of the T and WORK arrays, returns these
!>          values as the first entries of the T and WORK arrays, and no error
!>          message related to T or WORK is issued by XERBLA.
!>          If LWORK = -1, the routine calculates optimal size of WORK for the
!>          optimal performance and returns this value in WORK(1).
!>          If LWORK = -2, the routine calculates minimal size of WORK and 
!>          returns this value in WORK(1).
!>
[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
!>
!> The goal of the interface is to give maximum freedom to the developers for
!> creating any QR factorization algorithm they wish. The triangular 
!> (trapezoidal) R has to be stored in the upper part of A. The lower part of A
!> and the array T can be used to store any relevant information for applying or
!> constructing the Q factor. The WORK array can safely be discarded after exit.
!>
!> Caution: One should not expect the sizes of T and WORK to be the same from one 
!> LAPACK implementation to the other, or even from one execution to the other.
!> A workspace query (for T and WORK) is needed at each execution. However, 
!> for a given execution, the size of T and WORK are fixed and will not change 
!> from one query to the next.
!>
!>
Further Details particular to this LAPACK implementation:
!>
!> 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
!>                           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.
!>
!>

Definition at line 174 of file sgeqr.f.

176*
177* -- LAPACK computational routine --
178* -- LAPACK is a software package provided by Univ. of Tennessee, --
179* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
180*
181* .. Scalar Arguments ..
182 INTEGER INFO, LDA, M, N, TSIZE, LWORK
183* ..
184* .. Array Arguments ..
185 REAL A( LDA, * ), T( * ), WORK( * )
186* ..
187*
188* =====================================================================
189*
190* ..
191* .. Local Scalars ..
192 LOGICAL LQUERY, LMINWS, MINT, MINW
193 INTEGER MB, NB, MINTSZ, NBLCKS, LWMIN, LWREQ
194* ..
195* .. External Functions ..
196 LOGICAL LSAME
197 EXTERNAL lsame
198 REAL SROUNDUP_LWORK
199 EXTERNAL sroundup_lwork
200* ..
201* .. External Subroutines ..
202 EXTERNAL slatsqr, sgeqrt, xerbla
203* ..
204* .. Intrinsic Functions ..
205 INTRINSIC max, min, mod
206* ..
207* .. External Functions ..
208 INTEGER ILAENV
209 EXTERNAL ilaenv
210* ..
211* .. Executable statements ..
212*
213* Test the input arguments
214*
215 info = 0
216*
217 lquery = ( tsize.EQ.-1 .OR. tsize.EQ.-2 .OR.
218 $ lwork.EQ.-1 .OR. lwork.EQ.-2 )
219*
220 mint = .false.
221 minw = .false.
222 IF( tsize.EQ.-2 .OR. lwork.EQ.-2 ) THEN
223 IF( tsize.NE.-1 ) mint = .true.
224 IF( lwork.NE.-1 ) minw = .true.
225 END IF
226*
227* Determine the block size
228*
229 IF( min( m, n ).GT.0 ) THEN
230 mb = ilaenv( 1, 'SGEQR ', ' ', m, n, 1, -1 )
231 nb = ilaenv( 1, 'SGEQR ', ' ', m, n, 2, -1 )
232 ELSE
233 mb = m
234 nb = 1
235 END IF
236 IF( mb.GT.m .OR. mb.LE.n ) mb = m
237 IF( nb.GT.min( m, n ) .OR. nb.LT.1 ) nb = 1
238 mintsz = n + 5
239 IF ( mb.GT.n .AND. m.GT.n ) THEN
240 IF( mod( m - n, mb - n ).EQ.0 ) THEN
241 nblcks = ( m - n ) / ( mb - n )
242 ELSE
243 nblcks = ( m - n ) / ( mb - n ) + 1
244 END IF
245 ELSE
246 nblcks = 1
247 END IF
248*
249* Determine if the workspace size satisfies minimal size
250*
251 lwmin = max( 1, n )
252 lwreq = max( 1, n*nb )
253 lminws = .false.
254 IF( ( tsize.LT.max( 1, nb*n*nblcks + 5 ) .OR. lwork.LT.lwreq )
255 $ .AND. ( lwork.GE.n ) .AND. ( tsize.GE.mintsz )
256 $ .AND. ( .NOT.lquery ) ) THEN
257 IF( tsize.LT.max( 1, nb*n*nblcks + 5 ) ) THEN
258 lminws = .true.
259 nb = 1
260 mb = m
261 END IF
262 IF( lwork.LT.lwreq ) THEN
263 lminws = .true.
264 nb = 1
265 END IF
266 END IF
267*
268 IF( m.LT.0 ) THEN
269 info = -1
270 ELSE IF( n.LT.0 ) THEN
271 info = -2
272 ELSE IF( lda.LT.max( 1, m ) ) THEN
273 info = -4
274 ELSE IF( tsize.LT.max( 1, nb*n*nblcks + 5 )
275 $ .AND. ( .NOT.lquery ) .AND. ( .NOT.lminws ) ) THEN
276 info = -6
277 ELSE IF( ( lwork.LT.lwreq ) .AND. ( .NOT.lquery )
278 $ .AND. ( .NOT.lminws ) ) THEN
279 info = -8
280 END IF
281*
282 IF( info.EQ.0 ) THEN
283 IF( mint ) THEN
284 t( 1 ) = real( mintsz )
285 ELSE
286 t( 1 ) = real( nb*n*nblcks + 5 )
287 END IF
288 t( 2 ) = real( mb )
289 t( 3 ) = real( nb )
290 IF( minw ) THEN
291 work( 1 ) = sroundup_lwork( lwmin )
292 ELSE
293 work( 1 ) = sroundup_lwork( lwreq )
294 END IF
295 END IF
296 IF( info.NE.0 ) THEN
297 CALL xerbla( 'SGEQR', -info )
298 RETURN
299 ELSE IF( lquery ) THEN
300 RETURN
301 END IF
302*
303* Quick return if possible
304*
305 IF( min( m, n ).EQ.0 ) THEN
306 RETURN
307 END IF
308*
309* The QR Decomposition
310*
311 IF( ( m.LE.n ) .OR. ( mb.LE.n ) .OR. ( mb.GE.m ) ) THEN
312 CALL sgeqrt( m, n, nb, a, lda, t( 6 ), nb, work, info )
313 ELSE
314 CALL slatsqr( m, n, mb, nb, a, lda, t( 6 ), nb, work,
315 $ lwork, info )
316 END IF
317*
318 work( 1 ) = sroundup_lwork( lwreq )
319*
320 RETURN
321*
322* End of SGEQR
323*
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
sgeqrt
subroutine sgeqrt(m, n, nb, a, lda, t, ldt, work, info)
SGEQRT
Definition sgeqrt.f:139
ilaenv
integer function ilaenv(ispec, name, opts, n1, n2, n3, n4)
ILAENV
Definition ilaenv.f:160
slatsqr
subroutine slatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
SLATSQR
Definition slatsqr.f:172
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
sroundup_lwork
real function sroundup_lwork(lwork)
SROUNDUP_LWORK
Definition sroundup_lwork.f:59
Here is the call graph for this function:
Here is the caller graph for this function: