la_lapack_lsq_constrained Module Reference

Constrained least squares: equality constraints and the general Gauss-Markov model. More...

Functions/Subroutines
pure subroutine, public	la_sggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	SGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_dggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	DGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_qggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	QGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_sgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	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.
pure subroutine, public	la_dgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	DGGLSE: 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.
pure subroutine, public	la_qgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	QGGLSE: 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.
pure subroutine, public	la_cggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	CGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_zggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	ZGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_wggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	WGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
pure subroutine, public	la_cgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	CGGLSE: 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.
pure subroutine, public	la_zgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	ZGGLSE: 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.
pure subroutine, public	la_wgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	WGGLSE: 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.

Detailed Description

Constrained least squares: equality constraints and the general Gauss-Markov model.

Function/Subroutine Documentation

la_cggglm()

pure subroutine, public la_lapack_lsq_constrained::la_cggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(out)	x,
		complex(sp), dimension(*), intent(out)	y,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

CGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_cgglse()

pure subroutine, public la_lapack_lsq_constrained::la_cgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(out)	x,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

CGGLSE: 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.

Here is the call graph for this function:

la_dggglm()

pure subroutine, public la_lapack_lsq_constrained::la_dggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(*), intent(inout)	d,
		real(dp), dimension(*), intent(out)	x,
		real(dp), dimension(*), intent(out)	y,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_dgglse()

pure subroutine, public la_lapack_lsq_constrained::la_dgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(*), intent(inout)	c,
		real(dp), dimension(*), intent(inout)	d,
		real(dp), dimension(*), intent(out)	x,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DGGLSE: 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.

Here is the call graph for this function:

la_qggglm()

pure subroutine, public la_lapack_lsq_constrained::la_qggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(*), intent(inout)	d,
		real(qp), dimension(*), intent(out)	x,
		real(qp), dimension(*), intent(out)	y,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_qgglse()

pure subroutine, public la_lapack_lsq_constrained::la_qgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(*), intent(inout)	c,
		real(qp), dimension(*), intent(inout)	d,
		real(qp), dimension(*), intent(out)	x,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QGGLSE: 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.

Here is the call graph for this function:

la_sggglm()

pure subroutine, public la_lapack_lsq_constrained::la_sggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(out)	x,
		real(sp), dimension(*), intent(out)	y,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

SGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_sgglse()

pure subroutine, public la_lapack_lsq_constrained::la_sgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(inout)	c,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(out)	x,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_wggglm()

pure subroutine, public la_lapack_lsq_constrained::la_wggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(*), intent(inout)	d,
		complex(qp), dimension(*), intent(out)	x,
		complex(qp), dimension(*), intent(out)	y,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

WGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_wgglse()

pure subroutine, public la_lapack_lsq_constrained::la_wgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(*), intent(inout)	c,
		complex(qp), dimension(*), intent(inout)	d,
		complex(qp), dimension(*), intent(out)	x,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

WGGLSE: 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.

Here is the call graph for this function:

la_zggglm()

pure subroutine, public la_lapack_lsq_constrained::la_zggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(*), intent(inout)	d,
		complex(dp), dimension(*), intent(out)	x,
		complex(dp), dimension(*), intent(out)	y,
		complex(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

ZGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

la_zgglse()

pure subroutine, public la_lapack_lsq_constrained::la_zgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(*), intent(inout)	c,
		complex(dp), dimension(*), intent(inout)	d,
		complex(dp), dimension(*), intent(out)	x,
		complex(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

ZGGLSE: 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.

Here is the call graph for this function: