LAPACK 3.12.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches
cgels.f
Go to the documentation of this file.
1*> \brief <b> CGELS solves overdetermined or underdetermined systems for GE matrices</b>
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8*> \htmlonly
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cgels.f">
11*> [TGZ]</a>
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cgels.f">
13*> [ZIP]</a>
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cgels.f">
15*> [TXT]</a>
16*> \endhtmlonly
17*
18* Definition:
19* ===========
20*
21* SUBROUTINE CGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK,
22* INFO )
23*
24* .. Scalar Arguments ..
25* CHARACTER TRANS
26* INTEGER INFO, LDA, LDB, LWORK, M, N, NRHS
27* ..
28* .. Array Arguments ..
29* COMPLEX A( LDA, * ), B( LDB, * ), WORK( * )
30* ..
31*
32*
33*> \par Purpose:
34* =============
35*>
36*> \verbatim
37*>
38*> CGELS solves overdetermined or underdetermined complex linear systems
39*> involving an M-by-N matrix A, or its conjugate-transpose, using a QR
40*> or LQ factorization of A. It is assumed that A has full rank.
41*>
42*> The following options are provided:
43*>
44*> 1. If TRANS = 'N' and m >= n: find the least squares solution of
45*> an overdetermined system, i.e., solve the least squares problem
46*> minimize || B - A*X ||.
47*>
48*> 2. If TRANS = 'N' and m < n: find the minimum norm solution of
49*> an underdetermined system A * X = B.
50*>
51*> 3. If TRANS = 'C' and m >= n: find the minimum norm solution of
52*> an underdetermined system A**H * X = B.
53*>
54*> 4. If TRANS = 'C' and m < n: find the least squares solution of
55*> an overdetermined system, i.e., solve the least squares problem
56*> minimize || B - A**H * X ||.
57*>
58*> Several right hand side vectors b and solution vectors x can be
59*> handled in a single call; they are stored as the columns of the
60*> M-by-NRHS right hand side matrix B and the N-by-NRHS solution
61*> matrix X.
62*> \endverbatim
63*
64* Arguments:
65* ==========
66*
67*> \param[in] TRANS
68*> \verbatim
69*> TRANS is CHARACTER*1
70*> = 'N': the linear system involves A;
71*> = 'C': the linear system involves A**H.
72*> \endverbatim
73*>
74*> \param[in] M
75*> \verbatim
76*> M is INTEGER
77*> The number of rows of the matrix A. M >= 0.
78*> \endverbatim
79*>
80*> \param[in] N
81*> \verbatim
82*> N is INTEGER
83*> The number of columns of the matrix A. N >= 0.
84*> \endverbatim
85*>
86*> \param[in] NRHS
87*> \verbatim
88*> NRHS is INTEGER
89*> The number of right hand sides, i.e., the number of
90*> columns of the matrices B and X. NRHS >= 0.
91*> \endverbatim
92*>
93*> \param[in,out] A
94*> \verbatim
95*> A is COMPLEX array, dimension (LDA,N)
96*> On entry, the M-by-N matrix A.
97*> if M >= N, A is overwritten by details of its QR
98*> factorization as returned by CGEQRF;
99*> if M < N, A is overwritten by details of its LQ
100*> factorization as returned by CGELQF.
101*> \endverbatim
102*>
103*> \param[in] LDA
104*> \verbatim
105*> LDA is INTEGER
106*> The leading dimension of the array A. LDA >= max(1,M).
107*> \endverbatim
108*>
109*> \param[in,out] B
110*> \verbatim
111*> B is COMPLEX array, dimension (LDB,NRHS)
112*> On entry, the matrix B of right hand side vectors, stored
113*> columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS
114*> if TRANS = 'C'.
115*> On exit, if INFO = 0, B is overwritten by the solution
116*> vectors, stored columnwise:
117*> if TRANS = 'N' and m >= n, rows 1 to n of B contain the least
118*> squares solution vectors; the residual sum of squares for the
119*> solution in each column is given by the sum of squares of the
120*> modulus of elements N+1 to M in that column;
121*> if TRANS = 'N' and m < n, rows 1 to N of B contain the
122*> minimum norm solution vectors;
123*> if TRANS = 'C' and m >= n, rows 1 to M of B contain the
124*> minimum norm solution vectors;
125*> if TRANS = 'C' and m < n, rows 1 to M of B contain the
126*> least squares solution vectors; the residual sum of squares
127*> for the solution in each column is given by the sum of
128*> squares of the modulus of elements M+1 to N in that column.
129*> \endverbatim
130*>
131*> \param[in] LDB
132*> \verbatim
133*> LDB is INTEGER
134*> The leading dimension of the array B. LDB >= MAX(1,M,N).
135*> \endverbatim
136*>
137*> \param[out] WORK
138*> \verbatim
139*> WORK is COMPLEX array, dimension (MAX(1,LWORK))
140*> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
141*> \endverbatim
142*>
143*> \param[in] LWORK
144*> \verbatim
145*> LWORK is INTEGER
146*> The dimension of the array WORK.
147*> LWORK >= max( 1, MN + max( MN, NRHS ) ).
148*> For optimal performance,
149*> LWORK >= max( 1, MN + max( MN, NRHS )*NB ).
150*> where MN = min(M,N) and NB is the optimum block size.
151*>
152*> If LWORK = -1, then a workspace query is assumed; the routine
153*> only calculates the optimal size of the WORK array, returns
154*> this value as the first entry of the WORK array, and no error
155*> message related to LWORK is issued by XERBLA.
156*> \endverbatim
157*>
158*> \param[out] INFO
159*> \verbatim
160*> INFO is INTEGER
161*> = 0: successful exit
162*> < 0: if INFO = -i, the i-th argument had an illegal value
163*> > 0: if INFO = i, the i-th diagonal element of the
164*> triangular factor of A is zero, so that A does not have
165*> full rank; the least squares solution could not be
166*> computed.
167*> \endverbatim
168*
169* Authors:
170* ========
171*
172*> \author Univ. of Tennessee
173*> \author Univ. of California Berkeley
174*> \author Univ. of Colorado Denver
175*> \author NAG Ltd.
176*
177*> \ingroup gels
178*
179* =====================================================================
180 SUBROUTINE cgels( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK,
181 \$ INFO )
182*
183* -- LAPACK driver routine --
184* -- LAPACK is a software package provided by Univ. of Tennessee, --
185* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
186*
187* .. Scalar Arguments ..
188 CHARACTER TRANS
189 INTEGER INFO, LDA, LDB, LWORK, M, N, NRHS
190* ..
191* .. Array Arguments ..
192 COMPLEX A( LDA, * ), B( LDB, * ), WORK( * )
193* ..
194*
195* =====================================================================
196*
197* .. Parameters ..
198 REAL ZERO, ONE
199 parameter( zero = 0.0e+0, one = 1.0e+0 )
200 COMPLEX CZERO
201 parameter( czero = ( 0.0e+0, 0.0e+0 ) )
202* ..
203* .. Local Scalars ..
204 LOGICAL LQUERY, TPSD
205 INTEGER BROW, I, IASCL, IBSCL, J, MN, NB, SCLLEN, WSIZE
206 REAL ANRM, BIGNUM, BNRM, SMLNUM
207* ..
208* .. Local Arrays ..
209 REAL RWORK( 1 )
210* ..
211* .. External Functions ..
212 LOGICAL LSAME
213 INTEGER ILAENV
214 REAL CLANGE, SLAMCH
215 EXTERNAL lsame, ilaenv, clange, slamch
216* ..
217* .. External Subroutines ..
218 EXTERNAL cgelqf, cgeqrf, clascl, claset, ctrtrs, cunmlq,
219 \$ cunmqr, xerbla
220* ..
221* .. Intrinsic Functions ..
222 INTRINSIC max, min, real
223* ..
224* .. Executable Statements ..
225*
226* Test the input arguments.
227*
228 info = 0
229 mn = min( m, n )
230 lquery = ( lwork.EQ.-1 )
231 IF( .NOT.( lsame( trans, 'N' ) .OR. lsame( trans, 'C' ) ) ) THEN
232 info = -1
233 ELSE IF( m.LT.0 ) THEN
234 info = -2
235 ELSE IF( n.LT.0 ) THEN
236 info = -3
237 ELSE IF( nrhs.LT.0 ) THEN
238 info = -4
239 ELSE IF( lda.LT.max( 1, m ) ) THEN
240 info = -6
241 ELSE IF( ldb.LT.max( 1, m, n ) ) THEN
242 info = -8
243 ELSE IF( lwork.LT.max( 1, mn+max( mn, nrhs ) ) .AND.
244 \$ .NOT.lquery ) THEN
245 info = -10
246 END IF
247*
248* Figure out optimal block size
249*
250 IF( info.EQ.0 .OR. info.EQ.-10 ) THEN
251*
252 tpsd = .true.
253 IF( lsame( trans, 'N' ) )
254 \$ tpsd = .false.
255*
256 IF( m.GE.n ) THEN
257 nb = ilaenv( 1, 'CGEQRF', ' ', m, n, -1, -1 )
258 IF( tpsd ) THEN
259 nb = max( nb, ilaenv( 1, 'CUNMQR', 'LN', m, nrhs, n,
260 \$ -1 ) )
261 ELSE
262 nb = max( nb, ilaenv( 1, 'CUNMQR', 'LC', m, nrhs, n,
263 \$ -1 ) )
264 END IF
265 ELSE
266 nb = ilaenv( 1, 'CGELQF', ' ', m, n, -1, -1 )
267 IF( tpsd ) THEN
268 nb = max( nb, ilaenv( 1, 'CUNMLQ', 'LC', n, nrhs, m,
269 \$ -1 ) )
270 ELSE
271 nb = max( nb, ilaenv( 1, 'CUNMLQ', 'LN', n, nrhs, m,
272 \$ -1 ) )
273 END IF
274 END IF
275*
276 wsize = max( 1, mn + max( mn, nrhs )*nb )
277 work( 1 ) = real( wsize )
278*
279 END IF
280*
281 IF( info.NE.0 ) THEN
282 CALL xerbla( 'CGELS ', -info )
283 RETURN
284 ELSE IF( lquery ) THEN
285 RETURN
286 END IF
287*
288* Quick return if possible
289*
290 IF( min( m, n, nrhs ).EQ.0 ) THEN
291 CALL claset( 'Full', max( m, n ), nrhs, czero, czero, b, ldb )
292 RETURN
293 END IF
294*
295* Get machine parameters
296*
297 smlnum = slamch( 'S' ) / slamch( 'P' )
298 bignum = one / smlnum
299*
300* Scale A, B if max element outside range [SMLNUM,BIGNUM]
301*
302 anrm = clange( 'M', m, n, a, lda, rwork )
303 iascl = 0
304 IF( anrm.GT.zero .AND. anrm.LT.smlnum ) THEN
305*
306* Scale matrix norm up to SMLNUM
307*
308 CALL clascl( 'G', 0, 0, anrm, smlnum, m, n, a, lda, info )
309 iascl = 1
310 ELSE IF( anrm.GT.bignum ) THEN
311*
312* Scale matrix norm down to BIGNUM
313*
314 CALL clascl( 'G', 0, 0, anrm, bignum, m, n, a, lda, info )
315 iascl = 2
316 ELSE IF( anrm.EQ.zero ) THEN
317*
318* Matrix all zero. Return zero solution.
319*
320 CALL claset( 'F', max( m, n ), nrhs, czero, czero, b, ldb )
321 GO TO 50
322 END IF
323*
324 brow = m
325 IF( tpsd )
326 \$ brow = n
327 bnrm = clange( 'M', brow, nrhs, b, ldb, rwork )
328 ibscl = 0
329 IF( bnrm.GT.zero .AND. bnrm.LT.smlnum ) THEN
330*
331* Scale matrix norm up to SMLNUM
332*
333 CALL clascl( 'G', 0, 0, bnrm, smlnum, brow, nrhs, b, ldb,
334 \$ info )
335 ibscl = 1
336 ELSE IF( bnrm.GT.bignum ) THEN
337*
338* Scale matrix norm down to BIGNUM
339*
340 CALL clascl( 'G', 0, 0, bnrm, bignum, brow, nrhs, b, ldb,
341 \$ info )
342 ibscl = 2
343 END IF
344*
345 IF( m.GE.n ) THEN
346*
347* compute QR factorization of A
348*
349 CALL cgeqrf( m, n, a, lda, work( 1 ), work( mn+1 ), lwork-mn,
350 \$ info )
351*
352* workspace at least N, optimally N*NB
353*
354 IF( .NOT.tpsd ) THEN
355*
356* Least-Squares Problem min || A * X - B ||
357*
358* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
359*
360 CALL cunmqr( 'Left', 'Conjugate transpose', m, nrhs, n, a,
361 \$ lda, work( 1 ), b, ldb, work( mn+1 ), lwork-mn,
362 \$ info )
363*
364* workspace at least NRHS, optimally NRHS*NB
365*
366* B(1:N,1:NRHS) := inv(R) * B(1:N,1:NRHS)
367*
368 CALL ctrtrs( 'Upper', 'No transpose', 'Non-unit', n, nrhs,
369 \$ a, lda, b, ldb, info )
370*
371 IF( info.GT.0 ) THEN
372 RETURN
373 END IF
374*
375 scllen = n
376*
377 ELSE
378*
379* Underdetermined system of equations A**T * X = B
380*
381* B(1:N,1:NRHS) := inv(R**H) * B(1:N,1:NRHS)
382*
383 CALL ctrtrs( 'Upper', 'Conjugate transpose','Non-unit',
384 \$ n, nrhs, a, lda, b, ldb, info )
385*
386 IF( info.GT.0 ) THEN
387 RETURN
388 END IF
389*
390* B(N+1:M,1:NRHS) = ZERO
391*
392 DO 20 j = 1, nrhs
393 DO 10 i = n + 1, m
394 b( i, j ) = czero
395 10 CONTINUE
396 20 CONTINUE
397*
398* B(1:M,1:NRHS) := Q(1:N,:) * B(1:N,1:NRHS)
399*
400 CALL cunmqr( 'Left', 'No transpose', m, nrhs, n, a, lda,
401 \$ work( 1 ), b, ldb, work( mn+1 ), lwork-mn,
402 \$ info )
403*
404* workspace at least NRHS, optimally NRHS*NB
405*
406 scllen = m
407*
408 END IF
409*
410 ELSE
411*
412* Compute LQ factorization of A
413*
414 CALL cgelqf( m, n, a, lda, work( 1 ), work( mn+1 ), lwork-mn,
415 \$ info )
416*
417* workspace at least M, optimally M*NB.
418*
419 IF( .NOT.tpsd ) THEN
420*
421* underdetermined system of equations A * X = B
422*
423* B(1:M,1:NRHS) := inv(L) * B(1:M,1:NRHS)
424*
425 CALL ctrtrs( 'Lower', 'No transpose', 'Non-unit', m, nrhs,
426 \$ a, lda, b, ldb, info )
427*
428 IF( info.GT.0 ) THEN
429 RETURN
430 END IF
431*
432* B(M+1:N,1:NRHS) = 0
433*
434 DO 40 j = 1, nrhs
435 DO 30 i = m + 1, n
436 b( i, j ) = czero
437 30 CONTINUE
438 40 CONTINUE
439*
440* B(1:N,1:NRHS) := Q(1:N,:)**H * B(1:M,1:NRHS)
441*
442 CALL cunmlq( 'Left', 'Conjugate transpose', n, nrhs, m, a,
443 \$ lda, work( 1 ), b, ldb, work( mn+1 ), lwork-mn,
444 \$ info )
445*
446* workspace at least NRHS, optimally NRHS*NB
447*
448 scllen = n
449*
450 ELSE
451*
452* overdetermined system min || A**H * X - B ||
453*
454* B(1:N,1:NRHS) := Q * B(1:N,1:NRHS)
455*
456 CALL cunmlq( 'Left', 'No transpose', n, nrhs, m, a, lda,
457 \$ work( 1 ), b, ldb, work( mn+1 ), lwork-mn,
458 \$ info )
459*
460* workspace at least NRHS, optimally NRHS*NB
461*
462* B(1:M,1:NRHS) := inv(L**H) * B(1:M,1:NRHS)
463*
464 CALL ctrtrs( 'Lower', 'Conjugate transpose', 'Non-unit',
465 \$ m, nrhs, a, lda, b, ldb, info )
466*
467 IF( info.GT.0 ) THEN
468 RETURN
469 END IF
470*
471 scllen = m
472*
473 END IF
474*
475 END IF
476*
477* Undo scaling
478*
479 IF( iascl.EQ.1 ) THEN
480 CALL clascl( 'G', 0, 0, anrm, smlnum, scllen, nrhs, b, ldb,
481 \$ info )
482 ELSE IF( iascl.EQ.2 ) THEN
483 CALL clascl( 'G', 0, 0, anrm, bignum, scllen, nrhs, b, ldb,
484 \$ info )
485 END IF
486 IF( ibscl.EQ.1 ) THEN
487 CALL clascl( 'G', 0, 0, smlnum, bnrm, scllen, nrhs, b, ldb,
488 \$ info )
489 ELSE IF( ibscl.EQ.2 ) THEN
490 CALL clascl( 'G', 0, 0, bignum, bnrm, scllen, nrhs, b, ldb,
491 \$ info )
492 END IF
493*
494 50 CONTINUE
495 work( 1 ) = real( wsize )
496*
497 RETURN
498*
499* End of CGELS
500*
501 END
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine cgelqf(m, n, a, lda, tau, work, lwork, info)
CGELQF
Definition cgelqf.f:143
subroutine cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)
CGELS solves overdetermined or underdetermined systems for GE matrices
Definition cgels.f:182
subroutine cgeqrf(m, n, a, lda, tau, work, lwork, info)
CGEQRF
Definition cgeqrf.f:146
subroutine clascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)
CLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition clascl.f:143
subroutine claset(uplo, m, n, alpha, beta, a, lda)
CLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition claset.f:106
subroutine ctrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
CTRTRS
Definition ctrtrs.f:140
subroutine cunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
CUNMLQ
Definition cunmlq.f:168
subroutine cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
CUNMQR
Definition cunmqr.f:168