solving a sequence of sparse linear least squares subproblems

BIT
2000, Vol. 40, No. 4, pp. 001–004
0006-3835/00/4004-0001 $15.00
c Swets & Zeitlinger
SOLVING A SEQUENCE OF SPARSE
LINEAR LEAST SQUARES SUBPROBLEMS ∗
ÁNGEL SANTOS-PALOMO and PABLO GUERRERO-GARCÍA†
Department of Applied Mathematics, University of Málaga, Complejo Tecnológico,
Campus Teatinos, 29071 Málaga, Spain, emails: {santos,pablito}@ctima.uma.es
Abstract.
We describe how to maintain an explicit sparse orthogonal factorization in order to
solve the sequence of sparse linear least squares subproblems needed to implement an
active-set method to solve the nonnegative least squares problem for a matrix with more
columns than rows. In order to do that, we have adapted the sparse direct methodology
of Björck and Oreborn of late 80s in a similar way to Coleman and Hulbert, but without
forming the hessian matrix that is only positive semidefinite in this case; thus we have
developed a sparse counterpart of Reichel and Gragg’s QRUP package of early 90s.
We comment on our implementation on top of the sparse toolbox of Matlab 5, and
we emphasize the importance of Lawson and Hanson’s NNLS active-set method as an
alternative to Dax’s constructive proof of Farkas’ lemma.
AMS subject classification: 65F50, 65F20, 90C49, 49N15.
Key words: Sparse orthogonalization, Givens rotations, active-set methods, Farkas’
lemma.
1
The problem we want to solve.
In the least squares problem with nonnegative variables:
(1.1) minimize
1
kAy − ck22 ,
2
A ∈ Rn×m , y ∈ Rm ,
subject to y ≥ O,
it is usual [1, 5, 20] to assume n > m and that the matrix A has full column rank,
so the problem is strictly convex and its solution is unique. To compute such
solution, Lawson and Hanson’s NNLS method [16, §23.3] can be used. However,
they did not make any assumption about the dimensions of the matrix A in their
original presentation; indeed, the proof of the convergence of the NNLS method
only needs that, in the sequence of linear least squares (LLS) subproblems of
the form min kAk z − ck2 that this method has to solve, every matrix Ak has full
column rank.
We shall only deal with the case n < m, with A being a sparse full row rank
matrix. It is also a convex program (although not strictly, so there is no unique
∗ Review
(30th January 2007) of the Technical Report MA-03/03, September 2003.
author. TRs available at http://www.satd.uma.es/matap/investig.htm
† Corresponding
2
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
solution) and we call it the convex nonnegative least squares (NNLS) problem. In
fact there may be infinitely many vectors y that produce the (unique) minimum
value of the length of the residual. We do not require the solution to have
any particular distinguishing property as in algorithm 1 of Lötstedt [17] (i.e., it
does not necessarily have the least possible number of nonzero components, nor
the minimum euclidean norm among all solutions) but the columns of A which
correspond to positive components of y must be linearly independent.
The availability of a sparse algorithm for (1.1) makes possible an elegantly
simple way (due to Cline) of solving sparse least distance programming (LDP)
problems [16, §23.4]; moreover, least squares full column rank problems with
linear inequality constraints like those arising in constrained curve fitting [16,
§23.7] can be transformed into an LDP as described in [16, §23.5]. While problem
(1.1) has been used as a Phase I for a deficient-basis simplex method for linear
programming—in a similar way to the active-set algorithm P1 of Dantzig et
al. [8], it is not the purpose of this paper to test the suitability of this alternative.
Anyhow, we do not want to fail to emphasize in this paper that to obtain a
constructive proof of the Farkas’ lemma it would suffice to apply to problem
(1.1) the NNLS method itself in the original Lawson and Hanson’s [16] form.
Lemma 1.1. (Farkas’ lemma) Let A ∈ Rn×m and c ∈ Rn , then exactly one of
the following propositions must be true: or
(1.2)
c = Ay
for some
y ≥ O,
or else there exists a vector d satisfying
(1.3)
AT d ≥ O
and
cT d < 0.
In fact, Dax [10] has given another active-set method (different from NNLS)
to solve the same problem (1.1), thus providing a different constructive proof of
Farkas’ lemma. First, he proves the following theorem, whose corollary acts as
the separating hyperplane theorem.
Theorem 1.2. (Kuhn-Tucker) Let y ∗ ∈ Rm , d∗ = Ay ∗ − c ∈ Rn and w∗ =
T ∗
A d ∈ Rm ; then y ∗ is a solution of (1.1) if and only if y ∗ ≥ O, w∗ ≥ O and
(y ∗ )T w∗ = 0.
Corollary 1.3. Let y ∗ ∈ Rm be a solution of (1.1) and d∗ = Ay ∗ − c ∈ Rn .
It holds that if d∗ = O then y ∗ is a solution of Ay = c and y ≥ O; otherwise, d∗
is a solution of AT d ≥ O and cT d < 0.
In this way, the only thing that must be established is the existence of a solution
y ∗ of (1.1); to do this, Dax [10] has developed his active-set method using the
Kuhn-Tucker conditions, but the NNLS method itself can be used instead.
The algorithms of Dantzig et al. [8], Portugal et al. [20, pp. 627–628] and Dax
[10] can be thought of as variants of Lawson and Hanson’s NNLS method [16,
§23.3]. Since NNLS is the most well-known among them, it has been chosen in
this paper to illustrate how its sparse implementation can be accomplished as
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
3
an example of a situation in which a sequence of closely related LLS subproblems
has to be solved, attending thus to a need made in 1993 in the “Future work”
section of [8]:
(Algorithm) P1 should be implemented using sparse matrix methods
(. . . ) However, this would require substantial effort, as our algorithm
uses QR factorization, and would thus be more complicated to update
than the sparse LU factorization
as well as another one by Saunders in the same paper [8, p. 429]:
These results seem significant enough to spark interest in a sparse
NNLS implementation
This need has been expressed again recently (in October, 2002) by Barnes et
al. in the “Conclusions and future research” section of [3], where (1.1) occurs as
a subproblem in their primal-dual active-set LSPD method (closely related to
that of Dax [9]) for linear programming:
An efficient implementation of the LSPD algorithm using QR update
techniques for solving the NNLS problem is crucial in order to make
it competitive
This serves to highlight the importance of our main concern, namely a sparse
implementation of an active-set method for solving the convex NNLS problem.
The rest of this paper is structured as follows. A description (revealing some
interesting geometrical features) of Lawson and Hanson’s NNLS method and the
analysis of its convergence for the problem mentioned above is given in §2, along
with several remarks about closely related algorithms. In §3 we indicate how
to maintain an explicit suitable sparse orthogonal factorization by adapting the
sparse direct methodology of Björck [4] and Oreborn [18] in a similar way to
Coleman and Hulbert [6], but without forming the hessian matrix that is only
positive semidefinite in this case; thus we have developed a sparse counterpart
of Reichel and Gragg’s QRUP package [21]. After the conclusions in §4, an
appendix taken from [15, § B] with the Matlab code for the sparse technique
described in §3 is included for the interested reader to cut-and-paste.
From now on, we shall denote with k · k the euclidean vector norm. I and
O are respectively the identity and the zero matrix of appropriate dimension.
R(·) and N (·) are respectively the range and null space of a certain matrix.
The orthogonal projector onto a subspace S is denoted by PS . Subindexing and
construction of matrices is done using Matlab notation.
2
Active-set methods for convex NNLS problem.
The NNLS method works with complementary solutions, namely those vectors
[y; w] ∈ R2m satisfying w = AT (Ay − c) ∈ Rm and y T w = 0. Let us denote the
working set by Bk ⊂ 1 : m (with |Bk | = mk ) and its complement by Nk =
(1 : m)\Bk , partitioning accordingly the matrix A = [Ak , Nk ] ∈ Rn×m and the
4
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
vectors y = [yB ; yN ] and w = [wB ; wN ]. We include in Bk the indices of the
strictly positive components of y, thus Bk denotes our set of free variables and
Nk our set of fixed variables at their bounds (i.e., active constraints with respect
to y ≥ O). To obtain a complementary solution we set to zero the so-called
nonbasic variables yN and wB , whereas to obtain the values of the so-called
basic variables yB and wN we solve the unconstrained LLS subproblem
(2.1)
min kAk yB − ck
where Ak ∈ Rn×mk has full column rank, and then
(2.2)
wN = NkT (Ak yB − c).
Note that if we define d(k) , Ak yB − c then we have wB = ATk d(k) = O, since
d(k) ∈ N (ATk ) is the negative residual of the LLS problem (2.1). It is worth
noting that the solution technique employed in (2.1) is crucial for the success of
the algorithm; nevertheless, we shall defer this issue until the beginning of §3 to
clearly differentiate between the description of the method (given below) and its
sparse implementation.
Algorithm 2.1. Convex NNLS method
S0. Initialization. Let k ← 0 and define Bk = ∅, Nk = 1 : m, y (k) = O and
w(k) = −AT c.
S1. Check for optimality and pick a constraint to add. Compute wp = min{wi :
i ∈ Nk }. If wp < 0 then add p to Bk and delete p from Nk ; otherwise, stop
with y (k) as optimal solution.
S2. Determine the search direction, the maximum step length along such direction and the constraints to drop. Compute temporary variables ȳB by
solving (2.1). If ȳB > O then let y (k+1) ← [ȳB ; O] and go to S3; otherwise,
let q be a constraint such that
yq
yi
= min
: (i ∈ Bk ) and (ȳi ≤ 0)
αk =
yq − ȳq
yi − ȳi
and let y (k+1) ← [yB +αk (ȳB −yB ); O], delete from Bk all index j (q among
them) such that yj = 0, add them to Nk and go back to S2 with k ← k + 1.
S3. Prepare the next iteration. Compute wN by (2.2) and go back to S1 with
k ← k + 1.
A complementary solution is feasible if yB ≥ O and wN ≥ O. A principal
pivoting algorithm computes successive infeasible complementary solutions until
it reaches a feasible one, and such algorithm is called single pivoting if there
is only one element changing in the involved sets in every iteration (if not, it
is called block pivoting). Our description of the NNLS method above is not the
same as that given in Portugal et al. [20, pp. 627–628] as single principal pivoting
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
5
algorithm, because although both algorithms add constraints one after another,
NNLS can drop a block of constraints and also imposes that yB > O. The single
principal pivoting algorithm of Portugal et al. [20] allows yB ≥ O, which implies
two additional changes in step S2 of algorithm 2.1:
“If ȳB ≥ O” instead of “If ȳB > O”,
and “ȳi < 0” instead of “ȳi ≤ 0”.
These differences are important from both a theoretical and a practical point
of view, because it is not possible to ensure in the latter case that αk > 0 and
thus a strict improvement has to be ruled out; moreover, “If ȳB ≥ −” instead
of “If ȳB > ” would be used in fixed-precision arithmetic, where is some
prescribed tolerance, thus allowing small negative elements in yB that can cause
a change in the behaviour of the algorithm. Following Portugal et al. [20, p.
629], the problem we are dealing with cannot be solved with a block principal
pivoting algorithm, because they cannot be applied to rank-deficient linear least
squares problems with nonnegative variables. Although single addition is used
in algorithm 2.1, note that we do not rule out the possibility of multiple deletion;
nevertheless, the implementation given in §3 only deals with single deletion, and
multiple deletion is accomplished by a sequence of single deletions.
Now let us analyze the convergence of algorithm 2.1. It is straightforward to
prove that Ak has full column rank (since the constraints added are contrary to
the null-space descent direction d(k) , Ak yB − c with respect to cT x). It is also
easy to prove1 that if Ak+1 = [Ak , ap ] has full column rank and d(k) satisfies
ATk+1 d(k) = wp · emk +1 ,
wp < 0,
then ỹp is stricly positive, where ỹp is the last component of the solution ỹB of
min kAk+1 yB − (−d(k) )k. Lastly we need the following theorem too, which is not
proven in [16].
Theorem 2.1. Let Ak+1 = [Ak , ap ] be a full column rank matrix, d(k) =
−PN (ATk ) c and aTp d(k) = wp < 0. Then the last component ỹp of the solution ỹB
of min kAk+1 yB − (−d(k) )k coincides with the last component ŷp of the solution
ŷB of min kAk+1 yB − ck.
Proof. Using Schur complements there exist block-triangular matrices LS
and RS such that LS ATk+1 Ak+1 = RS , namely
#
"
T
(ATk Ak )−1 O
Ak Ak ATk ap
I
A†k ap
=
.
aTp Ak aTp ap
−aTp ATk †
1
OT aTp (ap − Ak A†k ap )
Now we can premultiply by LS both sides of the equalities
(ATk+1 Ak+1 )ỹB = −ATk+1 d(k)
leading to the systems RS ỹB =
1 It
O
−wp
and
(ATk+1 Ak+1 )ŷB = ATk+1 c,
"
#
A†k c
and RS ŷB =
.
aTp (c − Ak A†k c)
is an alternative wording of lemma (23.17) of Lawson and Hanson [16].
6
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
From the leftmost system we obtain that ỹp = −wp /(aTp (ap − Ak A†k ap )), and
from the rightmost one
ŷp =
aTp (c − Ak A†k c)
aTp (ap
−
Ak A†k ap )
,
−aTp d(k)
aTp (ap
−
Ak A†k ap )
,
−wp
aTp (ap
− Ak A†k ap )
= ỹp .
From theorem 2.1 we have that if ȳB is the solution of min kAk+1 yB −(−d(k) )k
or the solution of min kAk+1 yB − ck, then ȳp > 0. The termination of the inner
loop S2 can be obtained from the facts that at least the index q is deleted from
Bk in each iteration of this step and that at least a positive component has to be
left in Bk , namely that corresponding to ȳp . Hence, if Bk has t indices when S2
is reached, at most t − 1 iterations can be achieved before exiting towards S3.
The finite termination of the whole algorithm is proved from the fact that kd(k) k
has a strictly lower value each time S1 is reached, so y (k) and its associated set
Bk will be different from every one occurred before; since Bk is a subset of 1 : m
and there is only a finite number of such subsets, the whole algorithm finishes
after a finite number of iterations.
Another issue not treated in [16] is the occurrence of ties in S1; an illustrative
example can be found in [15, pp. 78–80]. Although this possibility cannot be
ruled out, the strict decrease of kd(k) k is not compromised at all. In practice, a
least-index tie-breaker would suffice.
Dax [10] studied the convergence of another active-set method to solve (1.1);
here we only point out that it also has to solve a sequence of least squares
problems (in this case of the form min kAk ∆yB − d(k) k), hence it can also be
implemented with the same sparse techniques we are going to introduce in the
next section. The same is true for the variants of the NNLS method given by
Dantzig et al. [8] and Portugal et al. [20, pp. 627–628].
All the algorithms mentioned so far in this section are “build-up” methods [8,
p. 429] in the sense that they avoid the calculation of an initial factorization of
A, which otherwise may well dominate the rest of the computation. Following
Clark and Osborne [7, p. 26], these algorithms are grouped under the name RLSA
and they have the advantage of being self-starting and avoiding a possibly badly
conditioned full system if the subproblems leading to an optimal solution are well
conditioned. By exchanging the roles of y and w, Clark and Osborne developed
the RLSD class of algorithms, which also dispense with the initial factorization of
A; although A was restricted to have full column rank in the original description
of these algorithms [7, and references therein], the convex case considered here
has been addressed in [19, p. 833]. Hence, the sparse counterpart of these papers
could also be dealt with the sparse technique of §3.
There exist alternative approaches based upon identifying (1.1) as a quadratic
programming (QP) problem of a rather simple special kind and particularizing
general QP primal techniques. As an example, the celebrated general QP primal
algorithm of Gill and Murray [12] has been particularized to obtain “build-down”
algorithms for (1.1), like algorithm 1 of Lötstedt [17] and LSSOL (LS1 option)
of Gill et al. [13]:
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
7
(i) Lötstedt [17, p. 210] updates a dense QR decomposition of a matrix AF
that consists of the columns of A corresponding to his set F of free variables. Moreover, F is selected in such a way that AF has full column rank
initially and such that rank(A) = rank(AF ); thus, our assumption that
rank(A) = n would imply that |F| = n and then his procedure would need
an initial QR factorization of A to choose the initial F.
(ii) The LS1 option of LSSOL maintains the dense QR factorization of A [8,
p. 427]. As pointed out in [13, §2] and [5, §5.2.3], in the full rank case this
method is essentially equivalent to Stoer’s 1971 algorithm, which is not
restricted to the full-column rank case [22, p. 405]. Björck and Oreborn
have developed a sparse implementation for a particularization of Stoer’s
algorithm to simple bounds [4] and non-negative constraints [18], but their
algorithms only consider the positive definite case [6, p. 375] and would
not be efficient in the n m context [8, p. 429].
On the other hand, we can also particularize general QP dual algorithms to
obtain “build-up” methods for (1.1). In fact, Dantzig et al. pointed out in [8,
p. 421, and references therein] that Lawson and Hanson’s NNLS method can be
obtained in this way from that of van de Panne and Whinston, and NNLS has
been generalized to deal with simple bounds [16, pp. 279–283] or general linear
inequality constraints [23]. The sparse case for this generalizations, not treated
in these works, could be addressed as described in §3.
A numerical comparison between a “build-up” (Dantzig et al.’s P1) and a
“build-down” (Gill et al.’s LSSOL) method for the dense version of the convex
NNLS problem corresponding to the smallest Netlib linear programs is included
in [8, §5.2], where a clear advantage was obtained by the former in both iteration
counts and run times, and so we do not treat this issue further here. What we
are going to show now is how the sparse methodology (not the algorithm!) of
Björck [4] and Oreborn [18] to implement a “build-down” method in the fullcolumn rank case can also be adapted to implement a “build-up” one in the
n m full-row rank context.
3
A sparse implementation.
In order to develop a sparse counterpart of Reichel and Gragg’s QRUP package
[21], let us show how to adapt the sparse direct methodology of Björck [4] and
Oreborn [18] to be able to apply the sparse NNLS algorithm with a “short-andfat” matrix A, i.e., with more columns than rows. They proposed an active-set
algorithm for the sparse least squares problem
minimize 21 y T Cy + dT y,
subject to l ≤ y ≤ u
y ∈ Rm
with C positive definite. In our problem
C = AT A and d = −AT c and ∀i ∈ 1 : m , li = 0 and ui = +∞
8
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
but C is positive semidefinite, hence to maintain a sparse QR factorization of
the working set matrix we proceed in a similar way as in Coleman and Hulbert
[6], but without forming the hessian matrix C.
Given a fixed matrix A ∈ Rn×m of full row rank with m ≥ n, we recur the
triangular factor Rk of the sparse QR factorization of Ak ∈ Rn×mk with mk ≤ n,
where Ak is a linearly independent subset of the columns of A and it is generated
from Ak−1 by adding/dropping a column. Furthermore, A is not restricted to
be triangular as in [4]. Note that in a sparse Matlab NNLS implementation
due to Adlers [1, §5.7], Rk is not updated but recomputed from scratch every
iteration by calling a sparse Cholesky routine after explicitly forming the matrix
of the normal equations, the reason being that Adler’s purpose was to compare
single and block pivoting in the strictly convex case. To be as close to the
implementation as possible, we shall use Lk , RkT to explain implementation
details and reserve Rk for more theoretical explanations.
Since we are going to do without the orthogonal factor due to sparsity reasons, the solution of the LLS subproblem (2.1) is done by the CSNE method
(see, for example, [5, p. 126]) as suggested by Björck [4, §5], which amounts to
performing a step of iterative refinement after having found the solution ȳB of
the seminormal equations
RkT Rk yB = ATk Ak yB = ATk c,
and then computing d(k) = Ak ȳB − c and wN = ATk d(k) . This contrasts with
the dense updatable QR-based approach used by Lötstedt [17, p. 210]. The
reason why a direct approach is chosen to solve (2.1) is that only one isolated
convex NNLS problem has to be solved in the Phase I application described
in §1. However, a sequence of closely related convex NNLS problems has to
be solved in the primal-dual active-set application, and an iterative approach
would perhaps be more efficient in this case as reported by Lötstedt [17] and
recommended by Dax [9]. Nevertheless, Dantzig et al. [8, §5.3] and Barnes et al.
[3] solve each convex NNLS problem with a dense NNLS direct subroutine, thus
avoiding slow convergence when dealing with ill-conditioned problems.
We have developed a Matlab toolbox based upon the following subsections
[15, §3.3]. The proof of the result (given in §3.1) needed to set up the static
data structure, as well as the correctness of the techniques to drop (§3.2) and
add (§3.3) a constraint, are essentially due to Björck [4] (see also [6, 5]). The
reason why these details are included is that we want to emphasize the fact (not
included in [4, 5, 6]) that a different choice in the order in which Givens rotations
are used in the classical dense case (see, e.g., [14, §12.5.2]) leads us to an efficient
sparse updating scheme. Moreover, in our sparse scheme Ak is not restricted to
be a column-echelon submatrix (as RFk is in [4, 5]) nor ATk Ak has to be formed
(as in [6]). To describe these techniques we use the notation of Coleman and
Hulbert [6], where `∨p denotes the bottom part of L(:, p) and `∧p the top part.
The notation for the Givens rotations is given in [14, p. 216].
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
3.1
9
Setting up the static structure.
First we determine a permutation matrix P such that P T AT AP has a Cholesky
factor as sparse as possible. In Matlab we can resort to:
>> p=colmmd(A); A=A(:,p); [ct,h,pa,po,R]=symbfact(A,’col’); spy(R’)
Note that we do not form (AP )T AP and that both colmmd and symbfact perform correctly even although AT A ∈ Rm×m is only positive semidefinite; furthermore, we a priori permute the columns of A in such a way that the natural
order coincides with the computed order. This static structure RT has enough
space to accommodate any Lk , so it constitutes an upper bound for the memory
needed [4, Theorem 4.1]. For this to be true, it is crucial that instead of labeling
each row and column of both ATk Ak and Lk with consecutive numbers, we label
them with the number of the row and column of AT A from which it comes. As
an example, if m = 6 and Bk = [2, 4, 5], then the matrix Lk will be stored in
the triangular mk × mk matrix R(Bk , Bk )T constructed by intersecting the rows
and columns of RT whose indices are in Bk :


×


⊗




×
×
T


Lk = R(Bk , Bk )T .
Bk = [2, 4, 5] and R = 

⊗
×
⊗




⊗
× × × × × ×
Therefore, the column ordering of A dictates that of Ak .
3.2
Dropping a constraint.
Let Bk = [B1 , B2 , . . . , Bi , . . . , Bmk ] be the current working set and let us drop
the constraint q , Bi to get Bk+1 . Then, to obtain the factor Lk+1 of ATk+1 Ak+1
given the factor Lk of ATk Ak , we first delete the row q of Lk to get a lower
Hessenberg matrix Hk such that Hk HkT = ATk+1 Ak+1 :




X
L11

 X X X
L11
.

Lk =  `T∧q `qq
Hk =
=
 X X X X

L21 `∨q L22
L21 `∨q L22
X X X X X
To obtain Lk+1 from Hk we could proceed [14, p. 608] as Gill and Murray
[11] did in the dense case, annihilating the diagonal of L22 by applying Givens
rotations to the column pairs (q, Bi+1 ), (Bi+1 , Bi+2 ), . . . , (Bmk −1 , Bmk ) and
then dropping the last column, namely
Gk , G(q, Bi+1 )G(Bi+1 , Bi+2 ) . . . G(Bmk −1 , Bmk ),
L11
L11
Hk Gk =
Lk+1 =
.
L21 L̃22 O
L21 L̃22
10
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
However, using this procedure L̃22 would be stored in the columns from q to
Bmk −1 ; nevertheless, L̃22 must be stored in the same place set up (and possibly
only partially used) for L22 , i.e., in the columns from Bi+1 to Bmk . This can
be done by annihilating `∨q with Givens rotations applied to the column pairs
(Bi+1 , q), (Bi+2 , q), . . . ,(Bmk , q), namely
Gk , G(Bi+1 , q)G(Bi+2 , q) . . . G(Bmk , q),
L11
L11
Hk Gk =
Lk+1 =
.
L21 O L̃22
L21 L̃22
As `∨q is sparse, only some of the rotations above have to be performed.
Summing up, if we allocate a dense intermediate column vector as column
m + 1 in our static structure to act as accumulator, we first initialize it with
the column q of Hk , restore the static structure of L(q, :) and L(:, q) (to be used
later if needed), and start the annihilation process of the elements of L(:, m + 1)
from top to bottom, by rotating with the corresponding column of L and taking
into account the intermediate fill-in in the accumulator:
Algorithm 3.1. Dropping a constraint
L(Bk , m + 1) ← [O; `∨q ]
while there are nonzero elements in L(:, m + 1) do
j ← index of first nonzero element of L(:, m + 1)
G ← Givens(L(j, j), L(j, m + 1))
{G ∈ R2×2 }
L(j : m, [j m + 1]) ← L(j : m, [j m + 1]) · G
{Sparse product}
end while
3.3
Adding a constraint.
Adding a constraint to the working set implies adding a new row aTp to the
matrix ATk . As the computational effort is minimized when the new row is added
at the bottom of the matrix, we will perform this addition in two stages: first
we will form the working set
B̃k+1 = [B1 , B2 , . . . , Bi−1 , Bi+1 , . . . , Bmk+1 , Bi ],
p , Bi
and then we will reorder it to obtain
Bk+1 = [B1 , B2 , . . . , Bi−1 , Bi , Bi+1 , . . . , Bmk+1 ],
because the order is crucial to maintain the static structure (cf. §3.1).
Let ATk Ak = Lk LTk and Ãk+1 = [Ak , ap ]; denoting with [`T , σ] the new row
to add to the bottom of Lk we have that there exists an orthogonal matrix Ṽk+1
such that
T Ak
Lk O O
ÃTk+1 =
=
Ṽk+1 , [L̃k+1 O]Ṽk+1 ,
aTp
`T σ 0
11
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
so then
ÃTk+1 Ãk+1 =
ATk Ak
O
However, it also holds that
Lk LTk
T
L̃k+1 L̃k+1 =
O
O
0
O
0
+
+
O
aTp Ak
O
`T LTk
ATk ap
aTp ap
Lk `
`T ` + σ 2
.
,
and from a comparison of the two equations above we conclude
q
Lk ` = ATk ap
and
σ = aTp ap − `T `.
Note that this technique, due to Gill and Murray [11], avoid the formation of the
column p of the matrix AT A in [6]. Moreover, it is more accurate to proceed as
in [5, §3.3.3] and consider ` , LTk δ, so CSNE can be applied to min kAk δ − ap k
and then compute σ = kAk δ − ap k.
Now we partition L̃k+1 in blocks by grouping on one side the rows and columns
with index less than p and those with index greater than p on the other side:


X




 X X X X X 
L11
L11


T
T 
.



X O X
`∧ σ `∨
L̃k+1 = L21 L22
Hk+1 =
=


T
T


X O X X
`∧
`∨ σ
L21 O L22
X O X X X
Reordering in accordance with Bk+1 , we have obtained a matrix Hk+1 that
T
satisfies Hk+1 Hk+1
= ATk+1 Ak+1 and is lower triangular but has a horizontal
spike in row p. So in order to get Lk+1 from Hk+1 we only have to apply
Givens rotations to the column pairs (p, Bmk+1 ), (p, Bmk+1 −1 ), . . . , (p, Bi+1 ) to
annihilate the elements of `T∨ from right to left using column p, thus
Lk+1 = Hk+1 G(p, Bmk+1 )G(p, Bmk+1 −1 ) . . . G(p, Bi+1 ).
Furthermore, as `T∨ is sparse we only have to perform some of the rotations
described above. Note that in the dense case [14, p. 609–610] the usual way to
proceed is


X




 X X X X X 
L11
L11


T
T

X X
O 
`∨ σ  = 
Hk+1 =  `∧
L̃k+1 =  L21 L22
,

 X X X
O 
L21 L22 O
`T∨ σ
`T∧
X X X X O
Lk+1 = Hk+1 G(Bmk+1 −1 , Bmk+1 )G(Bmk+1 −2 , Bmk+1 −1 ) . . . G(p, Bi+1 ),
but as in §3.2, the L̃22 matrix obtained after the rotations would not occupy the
same place as L22 .
12
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
Summing up, once ` and σ has been calculated, firstly we locate `T∧ at the
beginning of the row p of Lk+1 . Next, we allocate as column 0 of our static
structure a dense intermediate column vector initially zero to act as accumulator for column p of Lk+1 , and as row 0 a sparse vector whose first element
is initialized to σ and whose last part is initialized to `T∨ . Then we start the
annihilation process of the elements of L(0, p + 1: m) from right to left, by rotating column 0 with the corresponding column of L and taking into account
the intermediate fill-in in the accumulator; the sparsity of row 0 is exploited to
know which columns have to be rotated. Finally we move the contents of column 0 taking care of the static structure of L(: , p), since Barlow has proven in
[2] that non-structural non-zero elements (i.e., those that do not fit into the predicted structure due to rounding errors) can be omitted without compromising
the numerical accuracy.
Algorithm 3.2. Adding a constraint
L(p, [0 Bk ]) ← [0, `T∧ , OT ]
L(0, [0 Bk ]) ← [σ, OT , `T∨ ]
while there are nonzero elements in L(0, p + 1: m) do
j ← index of last nonzero element of L(0, p + 1: m)
G ← Givens(L(0, 0), L(0, j))
{G ∈ R2×2 }
L([0 j: m], [0 j]) ← L([0 j: m], [0 j]) · G
{Sparse product}
end while
L([0 p], 0) ← L([p 0], 0)
L(: , p) ← L(: , 0)
4
{Sparse assignement}
Conclusions.
Reichel and Gragg’s QRUP package of early 90s [21] can be used to solve a
sequence of dense closely related linear least squares subproblems. The aim of
this paper was to develop its sparse counterpart in a Matlab computational
environment, and therefore we have analyzed how to maintain an explicit sparse
orthogonal factorization in order to solve the sequence of sparse linear least
squares subproblems needed to implement an active-set method to solve the
nonnegative least squares problem for a matrix with more columns than rows.
These active-set methods constitute constructive proofs of Farkas’ lemma.
REFERENCES
1. M. Adlers, Sparse Least Squares Problems with Box Constraints, Licentiat thesis,
Department of Mathematics, Linköping University, 1998.
2. J. L. Barlow, On the use of structural zeros in orthogonal factorization, SIAM J.
Sci. Statist. Comput., 11 (1990), pp. 600–601.
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
13
3. E. Barnes, V. Chen, B. Gopalakrishnan and E. L. Johnson, A least-squares primaldual algorithm for solving linear programming problems, Oper. Res. Lett., 30 (October, 2002), pp. 289–294.
4. Å. Björck, A direct method for sparse least squares problems with lower and upper
bounds, Numer. Math., 54 (1988), pp. 19–32.
5. Å. Björck, Numerical Methods for Least Squares Problems, SIAM Publications,
Philadelphia, USA, 1996.
6. T. F. Coleman and L. A. Hulbert, A direct active set algorithm for large sparse
quadratic programs with simple lower bounds, Math. Progr., 45 (1989), pp. 373–
406.
7. D. I. Clark and M. R. Osborne, On linear restricted and interval least-squares
problems, IMA J. Numer. Anal., 8 (1988), pp. 23–36.
8. G. B. Dantzig, S. A. Leichner, and J. W. Davis, A strictly improving linear programming phase I algorithm, Ann. Oper. Res., 46/47 (1993), pp. 409–430.
9. A. Dax, Linear programming via least squares, Linear Algebra Appl., 111 (1988),
pp. 313–324.
10. A. Dax, An elementary proof of Farkas’ lemma, SIAM Rev., 39 (1997), pp. 503–507.
11. P. E. Gill, and W. Murray, A numerically stable form of the simplex algorithm,
Linear Algebra Appl., 7 (1973), pp. 99–138.
12. P. E. Gill, and W. Murray, Numerically stable methods for quadratic programming,
Math. Prog., 14 (1978), pp. 349–372.
13. P. E. Gill, and S. J. Hammarling, and W. Murray, and M. A. Saunders, and M. H.
Wright, User’s guide for LSSOL (version 1.0): A FORTRAN package for constrained linear least-squares and convex quadratic programming, Technical report,
Department of Operations Research, Stanford University, USA, January 1986.
14. G. H. Golub, and C. F. Van Loan, Matrix Computations, 3rd edition, The Johns
Hopkins University Press, Baltimore, MD, USA, 1996.
15. P. Guerrero-Garcı́a, Range-Space Methods for Sparse Linear Programs (Spanish),
Ph.D. thesis, Dept. Applied Mathematics, University of Málaga, Spain, July 2002.
16. C. L. Lawson, and R. J. Hanson, Solving Least Squares Problems, revised republication in 1995 by SIAM of the original work published by Prentice-Hall, Englewood
Cliffs, NJ, USA, 1974.
17. P. Lötstedt, Solving the minimal least squares problem subject to bounds on the
variables, BIT Numer. Math., 24 (1984), pp. 206–224.
18. U. Oreborn, A Direct Method for Sparse Nonnegative Least Squares Problems, Licentiat thesis, Department of Mathematics, Linköping University, Sweden, 1986.
19. M. R. Osborne, Degeneracy: Resolve or avoid?, J. Opl. Res. Soc., 43:8 (1992),
pp. 829–835.
20. L. F. Portugal, J. J. Júdice, and L. N. Vicente, A comparison of block pivoting
and interior-point algorithms for linear least squares problems with nonnegative
variables, Math. Comp., 63 (1994), pp. 625–643.
21. L. Reichel, and W. B. Gragg, Algorithm 686: FORTRAN subroutines for updating
the QR decomposition, ACM Trans. Math. Soft., 16:4 (1990), pp. 369–377.
22. J. Stoer, On the numerical solution of constrained least squares problems, SIAM
J. Numer. Anal., 8 (1971), pp. 382–411.
23. J. Stoer, A dual algorithm for solving degenerate linearly constrained linear least
squares problems, J. Num. Alg. App., 1 (1992), pp. 103–131.
14
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
Appendix: Matlab code.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Modified Sparse Least Squares Toolbox v1.2
==========================================
Autor:
Version:
Fecha:
Pablo Guerrero Garcia ([email protected])
1.2
Diciembre 2001
Objetivo:
Mantenimiento disperso del factor de Cholesky de
A(:,ACT)’*A(:,ACT), siendo A<-R^{nxm} y ACT<1:m.
Otras variables globales (ademas de A y ACT) son
NAC (complementario de ACT), b<-R^m y c<-R^n. El
factor de Cholesky de A(:,ACT)’*A(:,ACT) cabe en
el esqueleto predicho por L(ACT,ACT); ACT y NAC
se conservan ordenados. L<-R^{mxm+1} triangular
inferior dispersa determina cota superior de la
memoria a usar; indica con NaNs nnzs potenciales,
y la ultima columna se usa como acumulador. Capaz
de contemplar NaNs intermedios.
Contenido:
SqrIni
SqrIns
SqrDel
SqrRei
Givens
EjemMSLS
Inicializacion de estructuras de datos
Anyadir una restriccion a ACT
Eliminar una restriccion de ACT
Reinvertir A(:,ACT)
Realizar una rotacion de Givens
Ejemplo de utilizacion del toolbox
function SqrIni(modo,scal)
%SqrIni(modo,scal)
%
Inicializa un esqueleto L<-R^{mxm} triangular inferior de NaNs
%
tal que L(ACT,ACT) sea cota superior para el factor de Cholesky
%
de A(:,ACT)’*A(:,ACT) sea quien sea ACT. Si modo==’dmperm’
%
se reordenan las filas y las columnas de A (y b y c de forma
%
consistente) para que A quede en LBTF y asi el esqueleto de
%
dicho factor quede correctamente predicho en L(ACT,ACT); si
%
modo==’colmmd’ se reordenan las columnas de A (y b de forma
%
consistente) para que el esqueleto a priori en L(ACT,ACT)
%
sea cota superior para el factor de Cholesky. Tambien se asigna
%
memoria en la columna m+1 de L para que actue como acumulador
%
con n elementos distintos de cero como maximo; es necesario
%
para implementar de forma eficiente las rotaciones de Givens.
%
Se contemplan tecnicas de escalado (p.d., scal==’noscale’) como
%
la de que A(:,k) y c tengan norma euclidea unitaria (scal==’txt
%
book’), o la usada en CPLEX (normalizar A(:,k) en norma infinito,
%
y luego A(k,:), si scal==’cplex92’).
%
%
Ver tambien: dmperm, colmmd, symbfact
%
%
%
%
Autor:
Version:
Fecha:
Pablo Guerrero Garcia ([email protected])
1.3
Diciembre 2001
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
global ecuaciones L ACT NAC A b c
if nargin<1
modo = ’noperm’; scal = ’noscale’;
elseif nargin < 2 | isempty(scal)
scal = ’noscale’;
end;
[n,m] = size(A); % b <- R^m ; c <- R^n
switch lower(modo)
case ’dmperm’
% [p,q] = dmperm(DeSym(A’)); A = A(q,p);
[p,q] = dmperm(A’); A = A(q,p);
b = b(p); c = c(q); % ecuaciones = logical(ecuaciones(p));
case {’colmmd’,’colperm’,’colamd’}
% p = feval(lower(modo),DeSym(A)); A = A(:,p);
p = feval(lower(modo),A); A = A(:,p);
b = b(p); % ecuaciones = logical(ecuaciones(p));
case ’saunpm’
% [Saunders, 1972]: Demasiado denso
for k = 1:size(A,2)
priyults(:,k)=[min(find(A(:,k)));max(find(A(:,k)))];
end;
[foo,p] = sort(priyults(1,:));
A = A(:,p); b = b(p); % ecuaciones = logical(ecuaciones(p));
case {’symmmd’,’symrcm’,’symamd’}
% p = feval(lower(modo),DeSym(A’*A)); A = A(:,p);
p = feval(lower(modo),A’*A); A = A(:,p);
b = b(p); % ecuaciones = logical(ecuaciones(p));
case ’noperm’
disp(’No permuta ni filas ni columnas’);
otherwise
error(’Modo de ordenacion desconocido en SqrIni’)
end;
switch lower(scal)
case ’txtbook’
disp(’Escalado en norma euclidea ...’);
% denom = norm(DeSym(c),2);
denom = norm(c,2);
if denom > eps
for k = find(c)
A(k,:) = A(k,:)/denom; c(k) = c(k)/denom;
end;
end;
for k = 1:size(A,2)
%
denom = norm(DeSym(A(:,k)),2);
denom = norm(A(:,k),2);
if denom > eps
A(:,k) = A(:,k)/denom; b(k) = b(k)/denom;
end;
end;
case ’cplex92’
% [Bixby, 1992, p. 271]
disp(’Escalado en norma infinito como CPLEX ...’);
for k = 1:size(A,1)
%
denom = norm(DeSym(A(k,:)),inf);
denom = norm(A(k,:),inf);
if denom > eps
A(k,:) = A(k,:)/denom; c(k) = c(k)/denom;
end;
end;
15
16
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
for k = 1:size(A,2)
denom = norm(DeSym(A(:,k)),inf);
denom = norm(A(:,k),inf);
if denom > eps
A(:,k) = A(:,k)/denom; b(k) = b(k)/denom;
end;
end;
case ’noscale’
disp(’No escala ni filas ni columnas’);
otherwise
error(’Modo de escalado desconocido en SqrIni’)
end;
ACT = []; NAC = 1:m;
% [count,h,parent,post,L] = symbfact(DeSym(A),’col’); L = NaN*L’;
[count,h,parent,post,L] = symbfact(A,’col’); L = NaN*L’;
L(:,m+1) = spalloc(m,1,n);
%
function [pkap,zeta]=SqrIns(p,jota,zeta,pkap)
%[pkap,zeta]=SqrIns(p,jota,zeta,pkap)
%
Si L(ACT,ACT) es el factor de Cholesky de A(:,ACT)’*A(:,ACT)
%
y NAC(jota) = p, se elimina p de NAC y se inserta p de forma
%
ordenada en ACT; luego se actualiza L(ACT,ACT). Tanto p como
%
jota pueden ser []; ademas, jota puede no aparecer. Usa L(:,
%
end) como acumulador sccero denso por eficiencia al rotar.
%
Como variables de E/S opcionales estan zeta y pkap, respecti%
vamente solucion y residuo de min ||A(:,ACT)*z-A(:,p)||_2.
%
Capaz de contemplar NaNs intermedios.
%
%
Ver tambien: Givens
%
Autor:
Pablo Guerrero Garcia ([email protected])
%
Version:
1.2a
%
Fecha:
Octubre 2004
%
Algoritmia: [Gill&Murray,73],[Bjorck,88],[Coleman&Hulbert,89]
%
global L ACT NAC A
% NAC(jota) = p
if isempty(p)
p = NAC(jota);
elseif nargin == 1 | isempty(jota)
jota = find(NAC == p);
else
error(’Argumentos erroneos en SqrIns’);
end;
% Calcular ele y sigma usando CSNE; L(ACT,ACT) puede tener NaNs
[esqf,esqc] = find(isnan(L(ACT,ACT)));
for k = 1:length(esqf), L(ACT(esqf(k)),ACT(esqc(k))) = 0; end;
if nargin<3
zeta = L(ACT,ACT)’\(L(ACT,ACT)\(A(:,ACT)’*A(:,p)));
pkap = A(:,p)-A(:,ACT)*zeta;
% zeta = zeta + L(ACT,ACT)’\(L(ACT,ACT)\(A(:,ACT)’*pkap));
% pkap = A(:,p)-A(:,ACT)*zeta;
incz = L(ACT,ACT)’\(L(ACT,ACT)\(A(:,ACT)’*pkap)); zeta = zeta + incz;
pkap = pkap-A(:,ACT)*incz;
end;
ele = L(ACT,ACT)’*zeta;
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
sigma = norm(pkap);
% Si sigma == 0 entonces A(:,p) en R(A(:,ACT))
for k = 1:length(esqf), L(ACT(esqf(k)),ACT(esqc(k))) = NaN; end;
% Actualizar ACT y NAC
ACT1 = ACT(find(ACT < p)); la1 = length(ACT1); ACT2 = ACT(la1+1:end);
NAC(jota) = []; ACT = [ACT1 p ACT2];
% Subcolumna de L(:,end) como acumulador denso para sccero
esqf = find(L(:,end)); L(esqf,end) = 0;
% La parte superior de ele ocupa su lugar ...
if la1>0
esqf = find(L(p,ACT1) & ele(1:la1)’);
if ~isempty(esqf), L(p,ACT1(esqf)) = ele(esqf)’; end;
end;
% ... respetando el esqueleto disperso de L(p,ACT1)
irts = find(ele(la1+1:end)’);
% En ACT2(irts) estaran las columnas a rotar
for j = irts(end:-1:1)
[c,s,sigma] = Givens(sigma,ele(la1+j)); ele(la1+j) = 0;
esqf = find(L(ACT2,ACT2(j)));
% Creo que no es necesario hacer esqf(find(esqf<j)) = [];
% De entre las posiciones a rotar, poner los NaNs a 0
L(ACT2(esqf(isnan(L(ACT2(esqf),ACT2(j))))),ACT2(j)) = 0;
% Hacer la rotacion normalmente
L(ACT2(esqf),[end ACT2(j)]) = L(ACT2(esqf),[end ACT2(j)])*[c s; -s c];
% Recuperar NaNs no rellenados: no hace nada si esqueleto bien predicho
L(ACT2(setdford(esqf’,find(L(ACT2,ACT2(j)))’)’),ACT2(j))=NaN;
end;
L(p,p) = sigma;
% Mejor que hacer directamente L(ACT2,p) = sccero es ...
esqf = find(L(ACT2,p) & L(ACT2,end));
L(ACT2(esqf),p) = L(ACT2(esqf),end);
% ... pues respeta el esqueleto disperso de L(ACT2,p)
function w = SetDfOrd(u,v)
%SETDFORD Hace lo mismo que SETDIFF pero aprove%
cha que los conjuntos estan ordenados
%
y no tienen elementos repetidos.
%
% Sintaxis: w = SetDfOrd(u,v)
% Ejemplo: SetDfOrd([3 6 8 12 16],[1 3 7 12 14])
%
w=[];
while ~isempty(u)
if isempty(v), w=[w,u]; return; end;
if u(1)<v(1)
w=[w,u(1)]; u=u(2:end);
else
if u(1)==v(1), u=u(2:end); end;
v=v(2:end);
end;
end;
function SqrDel(q,indi)
%SqrDel(q,indi)
%
Si L(ACT,ACT) es el factor de Cholesky de A(:,ACT)’*A(:,ACT)
%
y ACT(indi) = q, se elimina q de ACT y se inserta q de forma
17
18
%
%
%
%
%
%
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
ordenada en NAC; luego se actualiza L(ACT,ACT). Tanto q como
indi pueden ser []; ademas, indi puede no aparecer. Usa L(:,
end) como acumulador scmmas1 denso por eficiencia al rotar.
Capaz de contemplar NaNs intermedios.
Ver tambien: Givens
%
Autor:
Pablo Guerrero Garcia ([email protected])
%
Version:
1.2
%
Fecha:
Diciembre 2001
%
Algoritmia: [Bjorck,88],[Coleman&Hulbert,89]
%
global L ACT NAC
% ACT(indi) = q
if isempty(q)
q = ACT(indi);
elseif nargin == 1 | isempty(indi)
indi = find(ACT == q);
end;
% Actualizar ACT y NAC
ACT1 = ACT(1:indi-1); ACT2 = ACT(indi+1:end);
NAC1 = NAC(find(NAC < q)); NAC2 = NAC(length(NAC1)+1:end);
ACT(indi) = []; NAC = [NAC1 q NAC2];
% Subcolumna de L(:,end) como acumulador denso para scmmas1
esqf = find(L(:,end)); L(esqf,end) = 0;
esqf = find(L(ACT2,q));
% Gestion de NaNs intermedios: no hace nada si esqueleto bien predicho
esqf = esqf(~isnan(L(ACT2(esqf),q)));
L(ACT2(esqf),end) = L(ACT2(esqf),q);
% Recuperar esqueleto de L(q,:) y de L(:,q)
esqf = find(L(q,ACT1)); L(q,ACT1(esqf)) = NaN; L(q,q) = NaN;
esqf = find(L(ACT2,q)); L(ACT2(esqf),q) = NaN;
% En rtcs estaran las columnas a rotar
rtcs = find(L(:,end));
while ~isempty(rtcs)
j = rtcs(1);
esqf = find(L(ACT2,j));
% Gestion de NaNs intermedios: no hace nada si esqueleto bien predicho
esqf = esqf(~isnan(L(ACT2(esqf),j)));
[c,s,L(j,j)] = Givens(L(j,j),L(j,end)); L(j,end) = 0;
L(ACT2(esqf(2:end)),[j end]) = L(ACT2(esqf(2:end)),[j end])*[c s; -s c];
rtcs = find(L(:,end));
end;
function SqrRei(modo)
%SqrRei(modo)
%
Recalcula el factor de Cholesky de A(:,ACT)’*A(:,ACT) y lo
%
almacena en L(ACT,ACT). Si modo==’exacto’ el esqueleto de
%
dicho factor esta correctamente predicho en L(ACT,ACT); si
%
modo==’cotsup’ el esqueleto a priori en L(ACT,ACT) es cota
%
superior para el factor de Cholesky, y hay que conservarlo
%
tras el recalculo.
%
%
Ver tambien: QR con argumento disperso
%
Autor:
Pablo Guerrero Garcia ([email protected])
SEQUENCE OF SPARSE LEAST SQUARES PROBLEMS
%
Version:
1.2
%
Fecha:
Diciembre 2001
%
global L ACT NAC A
[esqf,esqc] = find(L(:,1:end-1));
L(:,1:end-1) = sparse(esqf,esqc,NaN); L(:,end) = 0;
switch lower(modo)
case ’exacto’
L(ACT,ACT) = qr(A(:,ACT),0)’;
case ’cotsup’
[esqf,esqc] = find(L(ACT,ACT));
if length(ACT)==1
L(ACT,ACT) = A(:,ACT)’*A(:,ACT);
else % qr disperso no funciona bien con |ACT|=1 !!
L(ACT,ACT) = qr(A(:,ACT),0)’;
end;
for k = 1:length(esqf)
if L(ACT(esqf(k)),ACT(esqc(k))) == 0
L(ACT(esqf(k)),ACT(esqc(k))) = NaN;
end;
end;
otherwise
error(’Modo desconocido en SqrRei’)
end;
function [c,s,r] = Givens(a,b)
%GIVENS
Implementacion del algoritmo
%
%
[ c s; -s c ]^T [ a ; b
%
%
o equivalentemente
%
%
[ a , b ] [ c s; -s c
%
%
modificado para que devuelva
5.1.3 de [GolLoa,96]:216,
] = [ r ; 0 ]
] = [ r , 0 ]
r como en [Bjorck,96]:54.
%
Autor:
Pablo Guerrero Garcia ([email protected])
%
Version:
1.2
%
Fecha:
Diciembre 2001
%
if b==0
c = 1; s = 0; r = a;
% elseif DeSym(abs(b)) > DeSym(abs(a))
elseif abs(b) > abs(a)
cotangente = -a/b; tanalamenos1 = sqrt(1+cotangente^2);
s = 1/tanalamenos1; c = s*cotangente; r = -b*tanalamenos1;
else
cotangente = -b/a; tanalamenos1 = sqrt(1+cotangente^2);
c = 1/tanalamenos1; s = c*cotangente; r = a*tanalamenos1;
end;
function y=DeSym(x)
y=double(x);
% Cambiar por y=x; cuando no se use simbolico
19
20
%
%
%
%
Á. SANTOS-PALOMO AND P. GUERRERO-GARCÍA
Ejemplo de [GeLiNg,88]:104 con valores ajustados.
Ilustra el funcionamiento de las rutinas SqrIni,
SqrIns, SqrDel, SqrRei y Givens de la Modified
Sparse Least Squares Toolbox v1.2.
%
Autor:
Pablo Guerrero Garcia ([email protected])
%
Version:
1.2
%
Fecha:
Diciembre 2001
%
global L ACT NAC A b c
rand(’state’,0);
A=sparse([1 1 2 2 3 3 4 4 4 5 5 6 6 7 7 8 8],...
[1 6 2 4 1 3 2 4 6 5 6 1 6 3 4 2 4],randperm(17))’;
b=zeros(8,1); c=zeros(6,1); SqrIni(’dmperm’);
[fil,col]=find(A(:,[1 2 3 4 6 7]));
A(:,[1 2 3 4 6 7])=sparse(fil,col,[-3 5 3 4 sqrt(41) -sqrt(11) ...
850*sqrt(34) sqrt(533) sqrt(451)*sqrt(533) 4 -5 4 -5]);
full(A), full(L)
% Primero activamos la restriccion 7 y luego la 2 ...
SqrIns(7); ACT, NAC, full(L(ACT,ACT)), full(L)
SqrIns(2); ACT, NAC, full(L(ACT,ACT)), full(L)
% ... comprobamos reinvirtiendo ...
ACT=[2 7]; NAC=[1 3:6 8];
SqrRei(’exacto’); full(L(ACT,ACT)), full(L)
% ... despues anyadimos la restriccion 6
SqrIns(6); ACT, NAC,
% ACT=[2 6 7]; NAC=[1 3:5 8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% Ahora quitamos la 7 ...
SqrDel(7); ACT, NAC,
% ACT=[2 6]; NAC=[1 3:5 7:8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% ... y a continuacion ponemos la 3
SqrIns(3); ACT, NAC,
% ACT=[2 3 6]; NAC=[1 4:5 7:8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% ... tambien la 1 ...
SqrIns(1); ACT, NAC,
% ACT=[1 2 3 6]; NAC=[4:5 7:8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% ... y luego la 4 ...
SqrIns(4); ACT, NAC,
% ACT=[1 2 3 4 6]; NAC=[5 7:8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% Por ultimo quitamos la 2
SqrDel(2); ACT, NAC,
% ACT=[1 3 4 6]; NAC=[2 5 7:8]; SqrRei(’exacto’);
full(L(ACT,ACT)), full(L)
% Como Matlab no libera memoria al asignar un 0 en una matriz dispersa
% previamente asignada (con los NaN), al recuperar el esqueleto no
% se lanzara el reservador de memoria y podremos usar operadores
% dispersos sin problemas porque ya estan a 0 los NaN correspondientes.
%
% Reinversion final de comprobacion
ACT=[1 3 4 6]; NAC=[2 5 7:8]; SqrRei(’exacto’); full(L(ACT,ACT))