Abstract
We describe algorithm MINRES-QLP and its FORTRAN 90 implementation for solving symmetric or Hermitian linear systems or least-squares problems. If the system is singular, MINRES-QLP computes the unique minimum-length solution (also known as the pseudoinverse solution), which generally eludes MINRES. In all cases, it overcomes a potential instability in the original MINRES algorithm. A positive-definite pre-conditioner may be supplied. Our FORTRAN 90 implementation illustrates a design pattern that allows users to make problem data known to the solver but hidden and secure from other program units. In particular, we circumvent the need for reverse communication. Example test programs input and solve real or complex problems specified in Matrix Market format. While we focus here on a FORTRAN 90 implementation, we also provide and maintain MATLAB versions of MINRES and MINRES-QLP.
General Terms: Algorithms
Additional Key Words and Phrases: Krylov subspace method, Lanczos process, conjugate-gradient method, singular least-squares, linear equations, minimum-residual method, pseudoinverse solution, ill-posed problem, regression, sparse matrix, data encapsulation
1. INTRODUCTION
MINRES-QLP [Choi 2006; Choi et al. 2011] is a Krylov subspace method for computing the minimum-length and minimum-residual solution (also known as the pseudoinverse solution) x to the following linear systems or least-squares (LS) problems:
| (1) |
| (2) |
| (3) |
where A is an n × n symmetric or Hermitian matrix and b is a real or complex n-vector. Problems (1) and (2) are treated as special cases of (3). The matrix A is usually large and sparse, and it may be singular.1 It is defined by means of a user-written subroutine Aprod, whose function is to compute the product y = Aυ for any given vector υ.
Let xk be the solution estimate associated with MINRES-QLP’s kth iteration, with residual vector rk = b − Axk. Without loss of generality, we define x0 = 0. MINRES-QLP provides recurrent estimates of ‖xk‖, ‖rk‖, ‖Ark‖, ‖A‖, cond(A), and ‖Axk‖, which are used in the stopping conditions.
Other iterative methods specialized for symmetric systems Ax = b are the conjugate-gradient method (CG) [Hestenes and Stiefel 1952], SYMMLQ and MINRES [Paige and Saunders 1975], and SQMR [Freund and Nachtigal 1994]. Each method requires one product Aυk at each iteration for some vector υk. CG is intended for positive-definite A, whereas the other solvers allow A to be indefinite.
If A is singular, SYMMLQ requires the system to be consistent, whereas MINRES returns an LS solution for (3) but generally not the min-length solution; see [Choi 2006; Choi et al. 2011] for examples. SQMR without preconditioning is mathematically equivalent to MINRES but could fail on a singular problem. To date, MINRES-QLP is probably the most suitable CG-type method for solving (3).
In some cases, the more established symmetric methods may still be preferable.
If A is positive definite, CG minimizes the energy norm of the error ‖x − xk‖A in each Krylov subspace and requires slightly less work per iteration. However, CG, MINRES, and MINRES-QLP do reduce ‖x − xk‖A and ‖x − xk‖ monotonically. Also, MINRES and MINRES-QLP often reduce ‖rk‖ to the desired level significantly sooner than does CG, and the backward error for each xk decreases monotonically. (See Section 2.4 and Fong [2011] and Fong and Saunders [2012].)
If A is indefinite but Ax = b is consistent (e.g., if A is nonsingular), SYMMLQ requires slightly less work per iteration, and it reduces the error norm ‖x − xk‖ monotonically. MINRES and MINRES-QLP usually reduce ‖x −xk‖ [Fong 2011; Fong and Saunders 2012].
If A is indefinite and well conditioned and Ax = b is consistent, MINRES might be preferable to MINRES-QLP because it requires the same number of iterations but slightly less work per iteration.
MINRES and MINRES-QLP require a preconditioner to be positive definite. SQMR might be preferred if A is indefinite and an effective indefinite preconditioner is available.
MINRES-QLP has two phases. Iterations start in the MINRES phase and transfer to the MINRES-QLP phase when a subproblem (see (8)) becomes ill-conditioned by a certain measure. If every subproblem is of full rank and well-conditioned, the problem can be solved entirely in the MINRES phase, where the cost per iteration is essentially the same as for MINRES. In the MINRES-QLP phase, one more work vector and 5n more multiplications are used per iteration.
MINRES-QLP described here is implemented in FORTRAN 90 for real double-precision problems. It contains no machine-dependent constants and does not use any features from later standards. It requires an auxiliary subroutine Aprod and, if a preconditioner is supplied, a second subroutine Msolve. We also provide a complex implementation for Hermitian problems. Precision other than double can be obtained by changing one line of code.
We also maintain a MATLAB implementation capable of solving both real and complex problems. All implementations are available at [SOL].
Table I lists the main notation used.
Table I.
Key Notation
| ‖ · ‖ | matrix or vector two-norm |
| Ā | Ā = A − σ I (see also σ below) |
| cond(A) | condition number of A with respect to two-norm = |
| ei | ith unit vector |
| ℓ | index of the last Lanczos iteration when βℓ+1 = 0 |
| n | order of A |
| null(A) | null space of A defined as {x ∈ ℝn | Ax = 0} |
| range(A) | column space of A defined as {Ax | x ∈ ℝn} |
| T | (right superscript to a vector or a matrix) transpose |
| x† | unique minimum-length least-squares solution of problem (3) |
| 𝒦k(A, b) | kth Krylov subspace defined as span{b, Ab,…, Ak−1b} |
| ε | machine precision |
| σ | real scalar shift to diagonal of A |
1.1. Least-Squares Methods
Further existing methods that could be applied to (3) are CGLS and LSQR [Paige and Saunders 1982a, 1982b], LSMR [Fong and Saunders 2011], and GMRES [Saad and Schultz 1986], all of which reduce ‖rk‖ monotonically. The first three methods would require two products Aυk and Auk each iteration and would be generating points in less favorable subspaces. GMRES requires only products Aυk and could use any nonsingular (possibly indefinite) preconditioner. It needs increasing storage and work each iteration, perhaps requiring restarts, but it could be more effective than MINRES or MINRES-QLP (and the other solvers) if few total iterations were required. Table II summarizes the computational requirements of each method.
Table II.
Comparison of Various Least-Squares Solvers on n × n Systems (3)
| Solver | Storage | Work per Iteration |
Products per Iteration |
Systems to Solve per Iteration with Preconditioner |
|---|---|---|---|---|
| MINRES | 7n | 9n | 1 | 1 |
| MINRES-QLP | 7n – 8n | 9n – 14n | 1 | 1 |
| GMRES(m) | (m + 2)n | (m + 3 + 1/m)n | 1 | 1 |
| CGLS | 4n | 5n | 2 | 2 |
| LSQR | 5n | 8n | 2 | 2 |
| LSMR | 6n | 9n | 2 | 2 |
Storage refers to memory required by working vectors in the solvers. Work counts number of floating-point multiplications. On inconsistent systems, all solvers below except MINRES and GMRES with restart parameter m return the minimum-length LS solution (assuming no preconditioner).
1.2. Regularization
We do not discourage using CGLS, LSQR, or LSMR if the goal is to regularize an ill-posed problem using a small damping factor λ > 0 as follows:
| (4) |
However, this approach destroys the original problem’s symmetry. The normal equation of (4) is (A2 + λ2 I)x = Ab, which suggests that a diagonal shift to A may well serve the same purpose in some cases. For symmetric positive-definite A, Ā = A − σ I with σ < 0 enjoys a smaller condition number. When A is indefinite, a good choice of σ may not exist, for example, if the eigenvalues of A were symmetrically positioned around zero. When this symmetric form is applicable, it is convenient in MINRES and MINRES-QLP; see (3), (5), and (15). We also remark that MINRES and MINRES-QLP produce good estimates of the largest and smallest singular values of Ā (via diagonal values of Rk or Lk in (7) and (11); see Choi et al. [2011, Section 4]).
Three other regularization tools in the literature (see Golub and Van Loan [1996, Sections 12.1.1–12.1.3] and Hansen [1998]) are LSQI, cross-validation, and L-curve. LSQI involves solving a nonlinear equation and is not immediately compatible with the Lanczos framework. Cross-validation takes one row out at a time and thus does not preserve symmetry. The L-curve approach for a CG-type method takes iteration k as the regularization parameter [Hansen 1998, Chap. 8] if both ‖rk‖ and ‖xk‖ are monotonic. By design, ‖rk‖ is monotonic in MINRES and MINRES-QLP, and so is ‖xk‖ when Ā is positive definite [Fong 2011]. Otherwise, we prefer the condition L-curve approach in Calvetti et al. [2000], which graphs cond(Tk) against ‖rk‖. Yet another L-curve feasible in MINRES-QLP is against ‖rk‖, since the former is also monotonic (but available two iterations in lag); see Section 2.4.
2. MATHEMATICAL BACKGROUND
Notation and details of algorithmic development from [Choi 2006; Choi et al. 2011] are summarized here. As noted earlier, “A” in (1)–(3) is treated as A− σ I.
2.1. Lanczos Process
MINRES and MINRES-QLP use the symmetric Lanczos process [Lanczos 1950] to reduce A to a tridiagonal form . The process is initialized with υ0 ≡ 0, β1 = ‖b‖, and β1υ1 = b. After k steps of the tridiagonalization, we have produced
| (5) |
where we choose βk > 0 to give ‖υk‖ = 1. Numerically,
is slightly better than (5) [Paige 1976], but we can express (5) in matrix form:
| (6) |
where Tk = tridiag(βi, αi, βi+1), i = 1, …, k. In exact arithmetic, the Lanczos vectors in the columns of Vk are orthonormal, and the process stops with k = ℓ when βℓ+1 = 0 for some ℓ ≤ n, and then AVℓ = VℓTℓ. The rank of Tℓ could be ℓ or ℓ − 1 (see Theorem 2.2).
2.2. MINRES Phase
MINRES-QLP typically starts with a MINRES phase, which applies a series of reflectors Qk to transform to an upper triangular matrix :
| (7) |
where
In the kth step, Qk,k+1 is effectively a Householder reflector of dimension 2 [Trefethen and Bau 1997, Exercise 10.4], and its action including its effect on later columns of Tj, k < j ≤ ℓ, is compactly described by
where the superscripts with numbers in parentheses indicate the number of times the values have been modified. The kth solution approximation to (3) is then defined to be xk = Vkyk, where yk solves the subproblem
| (8) |
When k < ℓ, Rk is nonsingular and the unique solution of this subproblem satisfies Rkyk = tk. Instead of solving for yk, MINRES solves by forward substitution, obtaining the last column dk of Dk at iteration k. At the same time, it updates xk ∈ 𝒦k(A, b) (see Table I for definition) via x0 ≡ 0 and
| (9) |
where one can show using Vk = DkRk that .
2.3. MINRES-QLP Phase
The MINRES phase transfers to the MINRES-QLP phase when an estimate of the condition number of A exceeds an input parameter trancond. Thus, trancond > 1/ε leads to MINRES iterates throughout (where ε ≈ 10−16 denotes the floating-point precision), whereas trancond = 1 generates MINRES-QLP iterates from the start.
Suppose for now that there is no MINRES phase. Then MINRES-QLP applies left reflections as in (7) and a further series of right reflections to transform Rk to a lower triangular matrix Lk = RkPk, where
In the kth step, the actions of Pk−2,k and Pk−1,k are compactly described by
| (10) |
The kth approximate solution to (3) is then defined to be xk = Vkyk = VkPkuk = Wkuk, where uk solves the subproblem
| (11) |
For k < ℓ, Rk and Lk are nonsingular because has full column rank by Lemma 2.1 below. It is only when k = ℓ and b ∉ range(A) that Rk and Lk are singular with rank ℓ − 1 by Theorem 2.2, in which case one can show that in (10) and with Lℓ−1 nonsingular. In any case, we need to solve only the nonsingular lower triangular systems Lkuk = tk or Lℓ−1uℓ−1 = tℓ−1. Then, uk and yk = Pkuk are the min-length solutions of (11) and (8), respectively.
MINRES-QLP updates xk−2 to obtain xk by short-recurrence orthogonal steps:
| (12) |
| (13) |
where wj refers to the jth column of Wk = VkPk and μi is the ith element of uk.
If this phase is preceded by a MINRES phase of k iterations (0 < k < ℓ), it starts by transferring the last three vectors dk−2, dk−1, dk to wk−2, wk−1, wk, and the solution estimate xk from (9) to in (12). This needs the last two rows of Lkuk = tk (to give μk−1, μk) and the relations Wk = DkLk and . The cheaply available right reflections Pk and the bottom right 3 × 3 submatrix of Lk (i.e., the last term in (10)) need to have been saved in the MINRES phase in order to facilitate the transfer.
2.4. Norm Estimates and Stopping Conditions
Short-term recurrences are used to estimate the following quantities (where we assume σ = 0 for simplicity):
where γ̅k and γ̲k are the largest and smallest diagonals of Lk in absolute value. The up (down) arrows in parentheses indicate that the associated quantities increase (decrease) monotonically. The last two estimates tend to their targets from below; see Choi [2006] and Choi et al. [2011] for derivation.
MINRES-QLP has 14 possible stopping conditions in five classes that use the preceding estimates and optional user-input parameters itnlim, rtol, Acondlim, and maxxnorm:
-
(C1)from Lanczos and the QLP factorization:
- k = itnlim; βk+1 < ε;
-
(C2)normwise relative backward errors (NRBE) [Paige and Strakoš 2002]:
- ‖rk‖/ (‖A‖ ‖xk‖ + ‖b‖) ≤ max(rtol, ε); ‖Ark‖/ (‖A‖ ‖rk‖) ≤ max(rtol, ε);
-
(C3)regularization attempts:
- cond(A) ≥ min(Acondlim, 0.1/ε); ‖xk‖ ≥ maxxnorm;
-
(C4)degenerate cases:
- β1 = 0 ⇒ b = 0 ⇒ x = 0 is the solution;
- β2 = 0 ⇒ υ2 = 0 ⇒ Ab = α1b,
- i.e., b and α1 are an eigenpair of A, and x = b/α1 solves Ax = b;
-
(C5)erroneous inputs:
- A not symmetric; M not symmetric; M not positive definite;
where M is a preconditioner to be described in the next section. For symmetry of A, it is not practical to check for all i, j = 1, …, n. Instead, we statistically test whether z = |xT(Ay)−yT(Ax)| is sufficiently small for two nonzero n-vectors x and y (e.g., each element in the vectors is drawn from the standard normal distribution). For positive definiteness of M, since M is positive definite if and only if M−1 is positive definite, we simply test that each iteration (see Section 3).
We find that the recurrence relations for ϕk and ψk hold to high accuracy. Thus xk is an acceptable solution of (3) if the computed value of ϕk or ψk is suitably small according to the NRBE tests in class (C2) above. When a condition in (C3) is met, the final xk may or may not be an acceptable solution.
The class (C1) tests for small βk+1 and are included in the unlikely case in practice that the theoretical Lanczos termination occurs. Ideally, one of the NRBE tests should cause MINRES-QLP to terminate. If not, it is an indication that the problem is very ill-conditioned, in which case the regularization and preconditioning techniques of Sections 1.2 and 3 may be helpful.
2.5. Two Theorems
We complete this section by presenting two theorems from Choi et al. [2011] with slightly simpler proofs.
Lemma 2.1. for all 1 ≤ k < ℓ.
Proof. For 1 ≤ k < ℓ, we have β2, …, βk+1 > 0 by definition. Hence, has full column rank.
Theorem 2.2. Tℓ is nonsingular if and only if b ∈ range(A). Furthermore, rank(Tℓ) = ℓ − 1 if b ∉ range(A).
Proof. We use AVℓ = VℓTℓ twice. First, if Tℓ is nonsingular, we can solve Tℓyℓ = β1e1 and then AVℓyℓ = VℓTℓyℓ = Vℓβ1e1 = b. Conversely, if b ∈ range(A), then range(Vℓ) ⊆ range(A). Suppose Tℓ is singular. Then there exists z ≠ 0 such that VℓTℓz = AVℓz = 0. That is, 0 ≠ Vℓz ∈ null(A). But this is impossible because Vℓz ∈ range(A) and null(A) ∩ range(Vℓ) = 0. Thus, Tℓ must be nonsingular.
We have shown that if b ∉ range(A), is singular, and therefore ℓ > rank(Tℓ) ≥ by Lemma 2.1. Therefore, rank(Tℓ) = ℓ − 1.
By Lemma 2.1 and Theorem 2.2, we are assured that the QLP decomposition without column pivoting [Stewart 1999; Choi et al. 2011] for is rank-revealing, which is a necessary precondition for solving a least-squares problem.
Theorem 2.3. In MINRES-QLP, xℓ is the minimum-length solution of (3).
Proof. yℓ comes from the min-length LS solution of Tℓyℓ ≈ β1e1 and thus satisfies the normal equation and yℓ ∈ range(Tℓ). Now xℓ = Vℓyℓ and Axℓ = AVℓyℓ = VℓTℓyℓ. Hence, . Thus, xℓ is an LS solution of (3). Since yℓ ∈ range(Tℓ), yℓ = Tℓz for some z, and so xℓ = Vℓyℓ = VℓTℓz = AVℓz ∈ range(A) is the min-length LS solution of (3).
3. PRECONDITIONING
Iterative methods can be accelerated if preconditioners are available and well-chosen. For MINRES-QLP, we want to choose a symmetric positive-definite matrix M to solve a nonsingular system (1) by implicitly solving an equivalent symmetric consistent system , where , and . This two-sided preconditioning preserves symmetry. Thus, we can derive preconditioned MINRES-QLP by applying MINRES-QLP to the equivalent problem and setting .
With preconditioned MINRES-QLP, we can solve a singular consistent system (2), but we will obtain a least-squares solution that is not necessarily the minimum-length solution (unless M = I). For inconsistent systems (3), preconditioning alters the least-squares norm to ‖ · ‖M−1, and the solution is of minimum length in the new norm space. We refer readers to Choi et al. [2011, Sect. 7] for a detailed discussion of various approaches to preserving the two-norm “minimum length.”
To derive MINRES-QLP, we define
| (14) |
Then, , where the square root is well defined because M is positive definite, and the following expressions replace the quantities in (5) in the Lanczos iterations:
| (15) |
We also need to solve the system Mqk = zk in (14) at each iteration.
In the MINRES phase, we define and update the solution of the original problem (1) by
In the MINRES-QLP phase, we define and update the solution estimate of problem (1) by orthogonal steps:
Let . Then, is an acceptable solution of (1) if the computed value of ϕk ≈ ‖r̄k‖ = ‖rk‖M−1 is sufficiently small.
We can now present our pseudocode in Algorithm 1. The reflectors are implemented in Algorithm 2 SymOrtho(a, b) for real a and b, which is a stable form for computing , and . The complexity is at most 6 flops and a square root. Algorithm 1 lists all steps of MINRES-QLP with preconditioning. For simplicity, w̄k is written as wk for all relevant k. Also, the output x solves (A − σ I)x ≈ b, but other outputs are associated with the preconditioned system.
4. IMPLEMENTATION AND TESTING
A detailed description of the contents and structure of the Fortran 90 package implementing MINRES-QLP for real and complex data may be found in the user manual that accompanies the software (also available as Choi and Saunders [2012]).
Our design spares users from implementing reverse communication, in which the solver would return control to the calling program whenever Aprod or Msolve were to be invoked. (While reverse communication is widely used in scientific computing with FORTRAN 77, the resulting code usually appears formidable and unrecognizable from the original pseudocode; see Dongarra et al. [1995] and Oliveira and Stewart [2006] for two examples of CG and numerical integration coded in FORTRAN 77 and 90, respectively.) Our MINRES-QLP implementation achieves the purpose of reverse communication while preserving code readability and thus maintainability. The FORTRAN 90 module structure allows a user’s Ax products and Mx = y solves to be implemented outside MINRES-QLP in the same way that MATLAB’s function handles operate.
In our development of FORTRAN 90 MINRES-QLP, we have created a suite of 117 test cases including singular matrices representative of real-world applications [Foster 2009; Davis and Hu 2011]. The test program outputs results to MINRESQLP.txt. If users need to modify subroutine MINRESQLP, they can run these test cases and search for the word “ appear” in the output file to check whether all tests are reported to be successful. For more sophisticated unit testing frameworks employed in large-scale scientific software development, see O’Boyle et al. [2008]. Further details of the numerical examples are given in Choi and Saunders [2012].
Finally, note that the choice of parameter values can have a critical effect on the convergence of iterative solvers. While the default parameter values in MINRES-QLP work well in most tests, they may need to be fine-tuned by trial and error, and for some applications it may be worthwhile to implement full or partial reorthogonalization of the Lanczos vectors [Simon 1984].
ALGORITHM 1.
Pseudocode of preconditioned MINRES-QLP for solving (A − σ I)x ≈ b. In the right-justified comments, .
| input: A, b, σ, M | |||
| 1 | z0 = 0, z1 = b, Solve Mq1 = z1, | [Initialize] | |
| 2 | w0 = w−1 = 0, x−2 = x−1 = x0 = 0 | ||
| 3 | c0, 1 = c0, 2 = c0, 3 = −1, s0, 1 = s0, 2 = s0, 3 = 0, τ0 = ω0 = χ−2 = χ−1 = χ0 = 0 | ||
| 4 | κ0 = 1, 𝒜0 = δ1 = γ−1 = γ0 = η−1 = η0 = η1 = ϑ−1 = ϑ0 = ϑ1 = μ−1 = μ0 = 0 | ||
| 5 | k = 0 | ||
| 6 | while no stopping condition is satisfied do | ||
| 7 | k ← k + 1 | ||
| 8 | pk = Aqk − σqk, | [Preconditioned Lanczos] | |
| 9 | |||
| 10 | Solve Mqk+1 = zk+1, | ||
| 11 | if k = 1 then ρk = ‖ [αk βk+1] ‖ else ρk = ‖ [βk αk βk+1] ‖ | ||
| 12 | [Previous left reflection…] | ||
| 13 | γk = sk−1, 1δk − ck−1, 1αk | [on middle two entries of ek…] | |
| 14 | εk+1 = sk−1, 1βk+1 | [produces first two entries in ek+1] | |
| 15 | δk+1 = −ck−1, 1βk+1 | ||
| 16 | [Current left reflection] | ||
| 17 | [First right reflection] | ||
| 18 | |||
| 19 | |||
| 20 | [Second right reflection…] | ||
| 21 | [to zero out ] | ||
| 22 | τk = ck1ϕk−1 | [Last element of tk] | |
| 23 | ϕk = sk1ϕk−1, ψk−1 = ϕk−1 ‖ [γk δk+1] ‖ | [Update ‖r̄k‖, ‖Ãr̄k−1‖] | |
| 24 | if k = 1 then γmin = γ1 else | ||
| 25 | [Update ‖Ã‖] | ||
| 26 | ωk = ‖ [ωk−1 τk] ‖, κk ← 𝒜k/γmin | [Update ‖Ãxk‖, cond(Ã)] | |
| 27 | [Update wk−2, wk−1, wk] | ||
| 28 | |||
| 29 | |||
| 30 | [Update μk−2] | ||
| 31 | [Update μk−1] | ||
| 32 | if then else μk = 0 | [Compute μk] | |
| 33 | [Update xk−2] | ||
| 34 | [Compute xk] | ||
| 35 | [Update ‖xk−2‖] | ||
| 36 | [Compute ‖xk‖] | ||
| 37 | x = xk, ϕ = ϕk, ψ = ϕk‖ [γk+1 δk+2] ‖, χ = χk, 𝒜 = 𝒜k, ω = ωk | ||
| output: x, ϕ, ψ, χ, 𝒜, κ, ω | |||
ALGORITHM 2.
Algorithm SymOrtho.
| input: a, b | ||||||
| 1 | if b = 0 then s = 0, | r = |a| | ||||
| 2 | if a = 0 then c = 1 else c = sign(a) | |||||
| 3 | else if a = 0 then | |||||
| 4 | c = 0, | s = sign(b), | r = |b| | |||
| 5 | else if |b| ≥ |a| then | |||||
| 6 | τ = a/b, | , | c = sτ, | r = b/s | ||
| 7 | else if |a| > |b| then | |||||
| 8 | τ = b/a, | , | s = cτ, | r = a/c | ||
| output: c, s, r | ||||||
ACKNOWLEDGMENTS
We thank Christopher Paige for his contribution to the theory of MINRES-QLP, including the simplified proof of Theorem 2.2. We also thank Tim Hopkins and David Saunders for testing and running our software on the NAG Fortran compiler and the Intel ifort compiler, resulting in more robust code. We are grateful to Zhaojun Bai and two anonymous reviewers for their patience and constructive comments. The first author also thanks Jed Brown, Ian Foster, Todd Munson, Gail Pieper, Stefan Wild, and Hong Zhang for their feedback, interest, and support during the development of this work. Finally, we express our gratitude to the SIAM SIAG/LA 2012 Linear Algebra Prize Committee for their favorable consideration of MINRES-QLP [Choi et al. 2011].
This work was supported in part by the Office of Advanced Scientific Computing Research, Office of Science, US Department of Energy contract DE-AC02-06CH11357; National Science Foundation grant CCR-0306662; Office of Naval Research grants N00014-02-1-0076 and N00014-08-1-0191; and US Army Research Laboratory through the Army High Performance Computing Research Center.
ACM acknowledges that this contribution was authored or coauthored by a contractor or affiliate of the U.S. Government. As such, the Government retains a nonexclusive, royalty-free right to publish or reproduce this article, or to allow others to do so, for Government purposes only.
Footnotes
Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permissions may be requested from Publications Dept., ACM, Inc., 2 Penn Plaza, Suite 701, New York, NY 10121-0701 USA, fax +1 (212) 869-0481, or permissions@acm.org.
A further input parameter σ (a real shift parameter) causes MINRES-QLP to treat “A” as if it were A−σ I. For example, “singular A” really means that A− σ I is singular.
Contributor Information
Sou-Cheng T. Choi, University of Chicago/Argonne National Laboratory
Michael A. Saunders, Stanford University
REFERENCES
- Calvetti Daniela, Lewis Bryan, Reichel Lothar. An L-curve for the MINRES method. In: Luk Franklin T., editor. Advanced Signal Processing Algorithms, Architectures, and Implementations X. Vol. 4116. SPIE; 2000. pp. 385–395. [Google Scholar]
- Choi Sou-Cheng Terrya. Ph.D. thesis. Stanford University, CA: ICME; 2006. Iterative methods for singular linear equations and least-squares problems. [Google Scholar]
- Choi Sou-Cheng T, Paige Christopher C, Saunders Michael A. MINRES-QLP: A Krylov subspace method for indefinite or singular symmetric systems. SIAM J. Sci. Comput. 2011;33(4):1810–1836. [Google Scholar]
- Choi Sou-Cheng T, Saunders Michael A. Tech. Rep. ANL/MCS-P3027-0812. Chicago, IL: Computation Institute, University of Chicago; 2012. Algorithm & documentation: MINRES-QLP for singular symmetric and Hermitian linear equations and least-squares problems. [Google Scholar]
- Davis Timothy A, Yifan Hu. The University of Florida sparse matrix collection. ACM Trans. Math. Softw. 2011;38(1):1:1–1:25. [Google Scholar]
- Dongarra Jack, Eijkhout Victor, Kalhan Ajay. Rep. UT-CS-95-291. University of Tennessee, TN; 1995. Reverse communication interface for linear algebra templates for iterative methods. [Google Scholar]
- Fong David C-L. Ph.D. thesis. Stanford, CA: ICME, Stanford University; 2011. Minimum-residual methods for sparse least-squares using Golub-Kahan bidiagonalization. [Google Scholar]
- Fong David C-L, Saunders Michael A. LSMR: An iterative algorithm for sparse least-squares problems. SIAM J. Sci. Comput. 2011;33:2950–2971. [Google Scholar]
- Fong David C-L, Saunders Michael A. CG versus MINRES: An empirical comparison. SQU J. Sci. 2012;17(1):44–62. [Google Scholar]
- Foster Leslie. 2009. San Jose State University singular matrix database. http://www.math.sjsu.edu/singular/matrices/. [Google Scholar]
- A new Krylov-Subspace method for symmetric indefinite linear systems. In: Freund Roland W, Nachtigal Noël M., editors; Ames WF, editor. Proceedings of the 14th IMACS World Congress on Computational and Applied Mathematics. IMACS; 1994. pp. 1253–1256. [Google Scholar]
- Golub Gene H, Van Loan Charles F. Matrix Computations. 3rd Ed. Baltimore, MD: Johns Hopkins University Press; 1996. [Google Scholar]
- Hansen Per Christian. Rank-Deficient and Discrete Ill-Posed Problems. SIAM, Philadelphia, PA: SIAM Monographs on Mathematical Modeling and Computation; 1998. [Google Scholar]
- Hestenes Magnus R, Stiefel Eduard. Methods of conjugate gradients for solving linear systems. J. Res. Nat. Bur. Standards. 1952;49:409–436. [Google Scholar]
- Lanczos Cornelius. An iteration method for the solution of the eigenvalue problem of linear differential and integral operators. J. Res. Nat. Bur. Standards. 1950;45:255–282. [Google Scholar]
- O’Boyle Noel M, Tenderholt Adam L, Langner Karol M. CCLIB: A library for package-independent computational chemistry algorithms. J. Comput. Chem. 2008;29(5):839–845. doi: 10.1002/jcc.20823. [DOI] [PubMed] [Google Scholar]
- Oliveira Suely, Stewart David. Writing Scientific Software: A Guide to Good Style. Cambridge, UK: Cambridge University Press; 2006. [Google Scholar]
- Paige Christopher C. Error analysis of the Lanczos algorithm for tridiagonalizing a symmetric matrix. J. Inst. Math. Appl. 1976;18(3):341–349. [Google Scholar]
- Paige Christopher C, Saunders Michael A. Solution of sparse indefinite systems of linear equations. SIAM J. Numer. Anal. 1975;12(4):617–629. [Google Scholar]
- Paige Christopher C, Saunders Michael A. LSQR: An algorithm for sparse linear equations and sparse least squares. ACM Trans. Math. Softw. 1982a;8(1):43–71. [Google Scholar]
- Paige Christopher C, Saunders Michael A. Algorithm 583; LSQR: Sparse linear equations and least-squares problems. ACM Trans. Math. Softw. 1982b;8(2):195–209. doi: 10.1145/2527267. [DOI] [PMC free article] [PubMed] [Google Scholar]
- Paige Christopher C, Strakoš Zdeněk. Residual and backward error bounds in minimum residual Krylov subspace methods. SIAM J. Sci. Comput. 2002;23(6):1899–1924. [Google Scholar]
- Saad Youcef, Schultz Martin H. GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems. SIAM J. Sci. Statist. Comput. 1986;7(3):856–869. [Google Scholar]
- Simon Horst D. The Lanczos algorithm with partial reorthogonalization. Math. Comput. 1984;42(165):115–142. [Google Scholar]
- SOL. Systems Optimization Laboratory. Stanford University; www.stanford.edu/group/SOL. [Google Scholar]
- Stewart GW. The QLP approximation to the singular value decomposition. SIAM J. Sci. Comput. 1999;20(4):1336–1348. [Google Scholar]
- Trefethen Lloyd N, Bau David., III . Numerical Linear Algebra. Philadelphia, PA: SIAM; 1997. [Google Scholar]
