LAPACK  3.8.0
LAPACK: Linear Algebra PACKage
sgelq.f
Go to the documentation of this file.
1 *
2 * Definition:
3 * ===========
4 *
5 * SUBROUTINE SGELQ( M, N, A, LDA, T, TSIZE, WORK, LWORK,
6 * INFO )
7 *
8 * .. Scalar Arguments ..
9 * INTEGER INFO, LDA, M, N, TSIZE, LWORK
10 * ..
11 * .. Array Arguments ..
12 * REAL A( LDA, * ), T( * ), WORK( * )
13 * ..
14 *
15 *
16 *> \par Purpose:
17 * =============
18 *>
19 *> \verbatim
20 *> SGELQ computes a LQ factorization of an M-by-N matrix A.
21 *> \endverbatim
22 *
23 * Arguments:
24 * ==========
25 *
26 *> \param[in] M
27 *> \verbatim
28 *> M is INTEGER
29 *> The number of rows of the matrix A. M >= 0.
30 *> \endverbatim
31 *>
32 *> \param[in] N
33 *> \verbatim
34 *> N is INTEGER
35 *> The number of columns of the matrix A. N >= 0.
36 *> \endverbatim
37 *>
38 *> \param[in,out] A
39 *> \verbatim
40 *> A is REAL array, dimension (LDA,N)
41 *> On entry, the M-by-N matrix A.
42 *> On exit, the elements on and below the diagonal of the array
43 *> contain the M-by-min(M,N) lower trapezoidal matrix L
44 *> (L is lower triangular if M <= N);
45 *> the elements above the diagonal are used to store part of the
46 *> data structure to represent Q.
47 *> \endverbatim
48 *>
49 *> \param[in] LDA
50 *> \verbatim
51 *> LDA is INTEGER
52 *> The leading dimension of the array A. LDA >= max(1,M).
53 *> \endverbatim
54 *>
55 *> \param[out] T
56 *> \verbatim
57 *> T is REAL array, dimension (MAX(5,TSIZE))
58 *> On exit, if INFO = 0, T(1) returns optimal (or either minimal
59 *> or optimal, if query is assumed) TSIZE. See TSIZE for details.
60 *> Remaining T contains part of the data structure used to represent Q.
61 *> If one wants to apply or construct Q, then one needs to keep T
62 *> (in addition to A) and pass it to further subroutines.
63 *> \endverbatim
64 *>
65 *> \param[in] TSIZE
66 *> \verbatim
67 *> TSIZE is INTEGER
68 *> If TSIZE >= 5, the dimension of the array T.
69 *> If TSIZE = -1 or -2, then a workspace query is assumed. The routine
70 *> only calculates the sizes of the T and WORK arrays, returns these
71 *> values as the first entries of the T and WORK arrays, and no error
72 *> message related to T or WORK is issued by XERBLA.
73 *> If TSIZE = -1, the routine calculates optimal size of T for the
74 *> optimum performance and returns this value in T(1).
75 *> If TSIZE = -2, the routine calculates minimal size of T and
76 *> returns this value in T(1).
77 *> \endverbatim
78 *>
79 *> \param[out] WORK
80 *> \verbatim
81 *> (workspace) REAL array, dimension (MAX(1,LWORK))
82 *> On exit, if INFO = 0, WORK(1) contains optimal (or either minimal
83 *> or optimal, if query was assumed) LWORK.
84 *> See LWORK for details.
85 *> \endverbatim
86 *>
87 *> \param[in] LWORK
88 *> \verbatim
89 *> LWORK is INTEGER
90 *> The dimension of the array WORK.
91 *> If LWORK = -1 or -2, then a workspace query is assumed. The routine
92 *> only calculates the sizes of the T and WORK arrays, returns these
93 *> values as the first entries of the T and WORK arrays, and no error
94 *> message related to T or WORK is issued by XERBLA.
95 *> If LWORK = -1, the routine calculates optimal size of WORK for the
96 *> optimal performance and returns this value in WORK(1).
97 *> If LWORK = -2, the routine calculates minimal size of WORK and
98 *> returns this value in WORK(1).
99 *> \endverbatim
100 *>
101 *> \param[out] INFO
102 *> \verbatim
103 *> INFO is INTEGER
104 *> = 0: successful exit
105 *> < 0: if INFO = -i, the i-th argument had an illegal value
106 *> \endverbatim
107 *
108 * Authors:
109 * ========
110 *
111 *> \author Univ. of Tennessee
112 *> \author Univ. of California Berkeley
113 *> \author Univ. of Colorado Denver
114 *> \author NAG Ltd.
115 *
116 *> \par Further Details
117 * ====================
118 *>
119 *> \verbatim
120 *>
121 *> The goal of the interface is to give maximum freedom to the developers for
122 *> creating any LQ factorization algorithm they wish. The triangular
123 *> (trapezoidal) L has to be stored in the lower part of A. The lower part of A
124 *> and the array T can be used to store any relevant information for applying or
125 *> constructing the Q factor. The WORK array can safely be discarded after exit.
126 *>
127 *> Caution: One should not expect the sizes of T and WORK to be the same from one
128 *> LAPACK implementation to the other, or even from one execution to the other.
129 *> A workspace query (for T and WORK) is needed at each execution. However,
130 *> for a given execution, the size of T and WORK are fixed and will not change
131 *> from one query to the next.
132 *>
133 *> \endverbatim
134 *>
135 *> \par Further Details particular to this LAPACK implementation:
136 * ==============================================================
137 *>
138 *> \verbatim
139 *>
140 *> These details are particular for this LAPACK implementation. Users should not
141 *> take them for granted. These details may change in the future, and are unlikely not
142 *> true for another LAPACK implementation. These details are relevant if one wants
143 *> to try to understand the code. They are not part of the interface.
144 *>
145 *> In this version,
146 *>
147 *> T(2): row block size (MB)
148 *> T(3): column block size (NB)
149 *> T(6:TSIZE): data structure needed for Q, computed by
150 *> SLASWLQ or SGELQT
151 *>
152 *> Depending on the matrix dimensions M and N, and row and column
153 *> block sizes MB and NB returned by ILAENV, SGELQ will use either
154 *> SLASWLQ (if the matrix is short-and-wide) or SGELQT to compute
155 *> the LQ factorization.
156 *> \endverbatim
157 *>
158 * =====================================================================
159  SUBROUTINE sgelq( M, N, A, LDA, T, TSIZE, WORK, LWORK,
160  $ INFO )
161 *
162 * -- LAPACK computational routine (version 3.7.0) --
163 * -- LAPACK is a software package provided by Univ. of Tennessee, --
164 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
165 * December 2016
166 *
167 * .. Scalar Arguments ..
168  INTEGER INFO, LDA, M, N, TSIZE, LWORK
169 * ..
170 * .. Array Arguments ..
171  REAL A( lda, * ), T( * ), WORK( * )
172 * ..
173 *
174 * =====================================================================
175 *
176 * ..
177 * .. Local Scalars ..
178  LOGICAL LQUERY, LMINWS, MINT, MINW
179  INTEGER MB, NB, MINTSZ, NBLCKS
180 * ..
181 * .. External Functions ..
182  LOGICAL LSAME
183  EXTERNAL lsame
184 * ..
185 * .. External Subroutines ..
186  EXTERNAL sgelqt, slaswlq, xerbla
187 * ..
188 * .. Intrinsic Functions ..
189  INTRINSIC max, min, mod
190 * ..
191 * .. External Functions ..
192  INTEGER ILAENV
193  EXTERNAL ilaenv
194 * ..
195 * .. Executable statements ..
196 *
197 * Test the input arguments
198 *
199  info = 0
200 *
201  lquery = ( tsize.EQ.-1 .OR. tsize.EQ.-2 .OR.
202  $ lwork.EQ.-1 .OR. lwork.EQ.-2 )
203 *
204  mint = .false.
205  minw = .false.
206  IF( tsize.EQ.-2 .OR. lwork.EQ.-2 ) THEN
207  IF( tsize.NE.-1 ) mint = .true.
208  IF( lwork.NE.-1 ) minw = .true.
209  END IF
210 *
211 * Determine the block size
212 *
213  IF( min( m, n ).GT.0 ) THEN
214  mb = ilaenv( 1, 'SGELQ ', ' ', m, n, 1, -1 )
215  nb = ilaenv( 1, 'SGELQ ', ' ', m, n, 2, -1 )
216  ELSE
217  mb = 1
218  nb = n
219  END IF
220  IF( mb.GT.min( m, n ) .OR. mb.LT.1 ) mb = 1
221  IF( nb.GT.n .OR. nb.LE.m ) nb = n
222  mintsz = m + 5
223  IF ( nb.GT.m .AND. n.GT.m ) THEN
224  IF( mod( n - m, nb - m ).EQ.0 ) THEN
225  nblcks = ( n - m ) / ( nb - m )
226  ELSE
227  nblcks = ( n - m ) / ( nb - m ) + 1
228  END IF
229  ELSE
230  nblcks = 1
231  END IF
232 *
233 * Determine if the workspace size satisfies minimal size
234 *
235  lminws = .false.
236  IF( ( tsize.LT.max( 1, mb*m*nblcks + 5 ) .OR. lwork.LT.mb*m )
237  $ .AND. ( lwork.GE.m ) .AND. ( tsize.GE.mintsz )
238  $ .AND. ( .NOT.lquery ) ) THEN
239  IF( tsize.LT.max( 1, mb*m*nblcks + 5 ) ) THEN
240  lminws = .true.
241  mb = 1
242  nb = n
243  END IF
244  IF( lwork.LT.mb*m ) THEN
245  lminws = .true.
246  mb = 1
247  END IF
248  END IF
249 *
250  IF( m.LT.0 ) THEN
251  info = -1
252  ELSE IF( n.LT.0 ) THEN
253  info = -2
254  ELSE IF( lda.LT.max( 1, m ) ) THEN
255  info = -4
256  ELSE IF( tsize.LT.max( 1, mb*m*nblcks + 5 )
257  $ .AND. ( .NOT.lquery ) .AND. ( .NOT.lminws ) ) THEN
258  info = -6
259  ELSE IF( ( lwork.LT.max( 1, m*mb ) ) .and .( .NOT.lquery )
260  $ .AND. ( .NOT.lminws ) ) THEN
261  info = -8
262  END IF
263 *
264  IF( info.EQ.0 ) THEN
265  IF( mint ) THEN
266  t( 1 ) = mintsz
267  ELSE
268  t( 1 ) = mb*m*nblcks + 5
269  END IF
270  t( 2 ) = mb
271  t( 3 ) = nb
272  IF( minw ) THEN
273  work( 1 ) = max( 1, n )
274  ELSE
275  work( 1 ) = max( 1, mb*m )
276  END IF
277  END IF
278  IF( info.NE.0 ) THEN
279  CALL xerbla( 'SGELQ', -info )
280  RETURN
281  ELSE IF( lquery ) THEN
282  RETURN
283  END IF
284 *
285 * Quick return if possible
286 *
287  IF( min( m, n ).EQ.0 ) THEN
288  RETURN
289  END IF
290 *
291 * The LQ Decomposition
292 *
293  IF( ( n.LE.m ) .OR. ( nb.LE.m ) .OR. ( nb.GE.n ) ) THEN
294  CALL sgelqt( m, n, mb, a, lda, t( 6 ), mb, work, info )
295  ELSE
296  CALL slaswlq( m, n, mb, nb, a, lda, t( 6 ), mb, work,
297  $ lwork, info )
298  END IF
299 *
300  work( 1 ) = max( 1, mb*m )
301  RETURN
302 *
303 * End of SGELQ
304 *
305  END
subroutine sgelqt(M, N, MB, A, LDA, T, LDT, WORK, INFO)
Definition: sgelqt.f:124
subroutine sgelq(M, N, A, LDA, T, TSIZE, WORK, LWORK, INFO)
Definition: sgelq.f:161
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine slaswlq(M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK, INFO)
Definition: slaswlq.f:152