LAPACK  3.10.1
LAPACK: Linear Algebra PACKage

◆ sgglse()

subroutine sgglse ( integer  M,
integer  N,
integer  P,
real, dimension( lda, * )  A,
integer  LDA,
real, dimension( ldb, * )  B,
integer  LDB,
real, dimension( * )  C,
real, dimension( * )  D,
real, dimension( * )  X,
real, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

SGGLSE solves overdetermined or underdetermined systems for OTHER matrices

Download SGGLSE + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 SGGLSE solves the linear equality-constrained least squares (LSE)
 problem:

         minimize || c - A*x ||_2   subject to   B*x = d

 where A is an M-by-N matrix, B is a P-by-N matrix, c is a given
 M-vector, and d is a given P-vector. It is assumed that
 P <= N <= M+P, and

          rank(B) = P and  rank( (A) ) = N.
                               ( (B) )

 These conditions ensure that the LSE problem has a unique solution,
 which is obtained using a generalized RQ factorization of the
 matrices (B, A) given by

    B = (0 R)*Q,   A = Z*T*Q.
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 matrices A and B. N >= 0.
[in]P
          P is INTEGER
          The number of rows of the matrix B. 0 <= P <= N <= M+P.
[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 T.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A. LDA >= max(1,M).
[in,out]B
          B is REAL array, dimension (LDB,N)
          On entry, the P-by-N matrix B.
          On exit, the upper triangle of the subarray B(1:P,N-P+1:N)
          contains the P-by-P upper triangular matrix R.
[in]LDB
          LDB is INTEGER
          The leading dimension of the array B. LDB >= max(1,P).
[in,out]C
          C is REAL array, dimension (M)
          On entry, C contains the right hand side vector for the
          least squares part of the LSE problem.
          On exit, the residual sum of squares for the solution
          is given by the sum of squares of elements N-P+1 to M of
          vector C.
[in,out]D
          D is REAL array, dimension (P)
          On entry, D contains the right hand side vector for the
          constrained equation.
          On exit, D is destroyed.
[out]X
          X is REAL array, dimension (N)
          On exit, X is the solution of the LSE problem.
[out]WORK
          WORK is REAL array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK. LWORK >= max(1,M+N+P).
          For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB,
          where NB is an upper bound for the optimal blocksizes for
          SGEQRF, SGERQF, SORMQR and SORMRQ.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal size of the WORK array, returns
          this value as the first entry of the WORK array, and no error
          message related to LWORK is issued by XERBLA.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit.
          < 0:  if INFO = -i, the i-th argument had an illegal value.
          = 1:  the upper triangular factor R associated with B in the
                generalized RQ factorization of the pair (B, A) is
                singular, so that rank(B) < P; the least squares
                solution could not be computed.
          = 2:  the (N-P) by (N-P) part of the upper trapezoidal factor
                T associated with A in the generalized RQ factorization
                of the pair (B, A) is singular, so that
                rank( (A) ) < N; the least squares solution could not
                    ( (B) )
                be computed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 178 of file sgglse.f.

180 *
181 * -- LAPACK driver routine --
182 * -- LAPACK is a software package provided by Univ. of Tennessee, --
183 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
184 *
185 * .. Scalar Arguments ..
186  INTEGER INFO, LDA, LDB, LWORK, M, N, P
187 * ..
188 * .. Array Arguments ..
189  REAL A( LDA, * ), B( LDB, * ), C( * ), D( * ),
190  $ WORK( * ), X( * )
191 * ..
192 *
193 * =====================================================================
194 *
195 * .. Parameters ..
196  REAL ONE
197  parameter( one = 1.0e+0 )
198 * ..
199 * .. Local Scalars ..
200  LOGICAL LQUERY
201  INTEGER LOPT, LWKMIN, LWKOPT, MN, NB, NB1, NB2, NB3,
202  $ NB4, NR
203 * ..
204 * .. External Subroutines ..
205  EXTERNAL saxpy, scopy, sgemv, sggrqf, sormqr, sormrq,
206  $ strmv, strtrs, xerbla
207 * ..
208 * .. External Functions ..
209  INTEGER ILAENV
210  EXTERNAL ilaenv
211 * ..
212 * .. Intrinsic Functions ..
213  INTRINSIC int, max, min
214 * ..
215 * .. Executable Statements ..
216 *
217 * Test the input parameters
218 *
219  info = 0
220  mn = min( m, n )
221  lquery = ( lwork.EQ.-1 )
222  IF( m.LT.0 ) THEN
223  info = -1
224  ELSE IF( n.LT.0 ) THEN
225  info = -2
226  ELSE IF( p.LT.0 .OR. p.GT.n .OR. p.LT.n-m ) THEN
227  info = -3
228  ELSE IF( lda.LT.max( 1, m ) ) THEN
229  info = -5
230  ELSE IF( ldb.LT.max( 1, p ) ) THEN
231  info = -7
232  END IF
233 *
234 * Calculate workspace
235 *
236  IF( info.EQ.0) THEN
237  IF( n.EQ.0 ) THEN
238  lwkmin = 1
239  lwkopt = 1
240  ELSE
241  nb1 = ilaenv( 1, 'SGEQRF', ' ', m, n, -1, -1 )
242  nb2 = ilaenv( 1, 'SGERQF', ' ', m, n, -1, -1 )
243  nb3 = ilaenv( 1, 'SORMQR', ' ', m, n, p, -1 )
244  nb4 = ilaenv( 1, 'SORMRQ', ' ', m, n, p, -1 )
245  nb = max( nb1, nb2, nb3, nb4 )
246  lwkmin = m + n + p
247  lwkopt = p + mn + max( m, n )*nb
248  END IF
249  work( 1 ) = lwkopt
250 *
251  IF( lwork.LT.lwkmin .AND. .NOT.lquery ) THEN
252  info = -12
253  END IF
254  END IF
255 *
256  IF( info.NE.0 ) THEN
257  CALL xerbla( 'SGGLSE', -info )
258  RETURN
259  ELSE IF( lquery ) THEN
260  RETURN
261  END IF
262 *
263 * Quick return if possible
264 *
265  IF( n.EQ.0 )
266  $ RETURN
267 *
268 * Compute the GRQ factorization of matrices B and A:
269 *
270 * B*Q**T = ( 0 T12 ) P Z**T*A*Q**T = ( R11 R12 ) N-P
271 * N-P P ( 0 R22 ) M+P-N
272 * N-P P
273 *
274 * where T12 and R11 are upper triangular, and Q and Z are
275 * orthogonal.
276 *
277  CALL sggrqf( p, m, n, b, ldb, work, a, lda, work( p+1 ),
278  $ work( p+mn+1 ), lwork-p-mn, info )
279  lopt = work( p+mn+1 )
280 *
281 * Update c = Z**T *c = ( c1 ) N-P
282 * ( c2 ) M+P-N
283 *
284  CALL sormqr( 'Left', 'Transpose', m, 1, mn, a, lda, work( p+1 ),
285  $ c, max( 1, m ), work( p+mn+1 ), lwork-p-mn, info )
286  lopt = max( lopt, int( work( p+mn+1 ) ) )
287 *
288 * Solve T12*x2 = d for x2
289 *
290  IF( p.GT.0 ) THEN
291  CALL strtrs( 'Upper', 'No transpose', 'Non-unit', p, 1,
292  $ b( 1, n-p+1 ), ldb, d, p, info )
293 *
294  IF( info.GT.0 ) THEN
295  info = 1
296  RETURN
297  END IF
298 *
299 * Put the solution in X
300 *
301  CALL scopy( p, d, 1, x( n-p+1 ), 1 )
302 *
303 * Update c1
304 *
305  CALL sgemv( 'No transpose', n-p, p, -one, a( 1, n-p+1 ), lda,
306  $ d, 1, one, c, 1 )
307  END IF
308 *
309 * Solve R11*x1 = c1 for x1
310 *
311  IF( n.GT.p ) THEN
312  CALL strtrs( 'Upper', 'No transpose', 'Non-unit', n-p, 1,
313  $ a, lda, c, n-p, info )
314 *
315  IF( info.GT.0 ) THEN
316  info = 2
317  RETURN
318  END IF
319 *
320 * Put the solutions in X
321 *
322  CALL scopy( n-p, c, 1, x, 1 )
323  END IF
324 *
325 * Compute the residual vector:
326 *
327  IF( m.LT.n ) THEN
328  nr = m + p - n
329  IF( nr.GT.0 )
330  $ CALL sgemv( 'No transpose', nr, n-m, -one, a( n-p+1, m+1 ),
331  $ lda, d( nr+1 ), 1, one, c( n-p+1 ), 1 )
332  ELSE
333  nr = p
334  END IF
335  IF( nr.GT.0 ) THEN
336  CALL strmv( 'Upper', 'No transpose', 'Non unit', nr,
337  $ a( n-p+1, n-p+1 ), lda, d, 1 )
338  CALL saxpy( nr, -one, d, 1, c( n-p+1 ), 1 )
339  END IF
340 *
341 * Backward transformation x = Q**T*x
342 *
343  CALL sormrq( 'Left', 'Transpose', n, 1, p, b, ldb, work( 1 ), x,
344  $ n, work( p+mn+1 ), lwork-p-mn, info )
345  work( 1 ) = p + mn + max( lopt, int( work( p+mn+1 ) ) )
346 *
347  RETURN
348 *
349 * End of SGGLSE
350 *
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine sormrq(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
SORMRQ
Definition: sormrq.f:168
subroutine strtrs(UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, INFO)
STRTRS
Definition: strtrs.f:140
subroutine sormqr(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
SORMQR
Definition: sormqr.f:168
subroutine sggrqf(M, P, N, A, LDA, TAUA, B, LDB, TAUB, WORK, LWORK, INFO)
SGGRQF
Definition: sggrqf.f:214
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:82
subroutine saxpy(N, SA, SX, INCX, SY, INCY)
SAXPY
Definition: saxpy.f:89
subroutine strmv(UPLO, TRANS, DIAG, N, A, LDA, X, INCX)
STRMV
Definition: strmv.f:147
subroutine sgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
SGEMV
Definition: sgemv.f:156
Here is the call graph for this function:
Here is the caller graph for this function: