GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-11 03:09:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Correct GMRES:

Browse Source 
* Fix error in calculation of residual at restart.
* Use relative residual as stopping criterion.
* Improve documentation.
This commit is contained in:
Kolja Brix 2014-08-02 18:39:15 +02:00
parent e51da9c3a8
commit 953ec08089
1 changed files with 80 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
unsupported/Eigen/src/IterativeSolvers/GMRES.h
View File

@ -27,7 +27,7 @@ namespace internal {
* \param iters on input: maximum number of iterations to perform * \param iters on input: maximum number of iterations to perform
* on output: number of iterations performed * on output: number of iterations performed
* \param restart number of iterations for a restart * \param restart number of iterations for a restart
* \param tol_error on input: residual tolerance * \param tol_error on input: relative residual tolerance
* on output: residuum achieved * on output: residuum achieved
* *
* \sa IterativeMethods::bicgstab() * \sa IterativeMethods::bicgstab()
@ -70,18 +70,24 @@ bool gmres(const MatrixType & mat, const Rhs & rhs, Dest & x, const Precondition
const int m = mat.rows(); const int m = mat.rows();
VectorType p0 = rhs - mat*x; // residual and preconditioned residual
const VectorType p0 = rhs - mat*x;
VectorType r0 = precond.solve(p0); VectorType r0 = precond.solve(p0);
const RealScalar r0Norm = r0.norm();
// is initial guess already good enough? // is initial guess already good enough?
if(abs(r0.norm()) < tol) { if(r0Norm == 0) {
tol_error=0;
return true; return true;
} }
// storage for Hessenberg matrix and Householder data
FMatrixType H = FMatrixType::Zero(m, restart + 1);
VectorType w = VectorType::Zero(restart + 1); VectorType w = VectorType::Zero(restart + 1);
FMatrixType H = FMatrixType::Zero(m, restart + 1); // Hessenberg matrix
VectorType tau = VectorType::Zero(restart + 1); VectorType tau = VectorType::Zero(restart + 1);
// storage for Jacobi rotations
std::vector < JacobiRotation < Scalar > > G(restart); std::vector < JacobiRotation < Scalar > > G(restart);
// generate first Householder vector // generate first Householder vector
@ -112,11 +118,10 @@ bool gmres(const MatrixType & mat, const Rhs & rhs, Dest & x, const Precondition
} }
if (v.tail(m - k).norm() != 0.0) { if (v.tail(m - k).norm() != 0.0) {
if (k <= restart) { if (k <= restart) {
// generate new Householder vector // generate new Householder vector
VectorType e(m - k - 1); VectorType e(m - k - 1);
RealScalar beta; RealScalar beta;
v.tail(m - k).makeHouseholder(e, tau.coeffRef(k), beta); v.tail(m - k).makeHouseholder(e, tau.coeffRef(k), beta);
H.col(k).tail(m - k - 1) = e; H.col(k).tail(m - k - 1) = e;
@ -125,74 +130,73 @@ bool gmres(const MatrixType & mat, const Rhs & rhs, Dest & x, const Precondition
v.tail(m - k).applyHouseholderOnTheLeft(H.col(k).tail(m - k - 1), tau.coeffRef(k), workspace.data()); v.tail(m - k).applyHouseholderOnTheLeft(H.col(k).tail(m - k - 1), tau.coeffRef(k), workspace.data());
} }
} }
if (k > 1) { if (k > 1) {
for (int i = 0; i < k - 1; ++i) { for (int i = 0; i < k - 1; ++i) {
// apply old Givens rotations to v // apply old Givens rotations to v
v.applyOnTheLeft(i, i + 1, G[i].adjoint()); v.applyOnTheLeft(i, i + 1, G[i].adjoint());
} }
} }
if (k<m && v(k) != (Scalar) 0) { if (k<m && v(k) != (Scalar) 0) {
// determine next Givens rotation
G[k - 1].makeGivens(v(k - 1), v(k));
// apply Givens rotation to v and w // determine next Givens rotation
v.applyOnTheLeft(k - 1, k, G[k - 1].adjoint()); G[k - 1].makeGivens(v(k - 1), v(k));
w.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
} // apply Givens rotation to v and w
v.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
w.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
}
// insert coefficients into upper matrix triangle // insert coefficients into upper matrix triangle
H.col(k - 1).head(k) = v.head(k); H.col(k - 1).head(k) = v.head(k);
bool stop=(k==m || abs(w(k)) < tol || iters == maxIters); bool stop=(k==m || abs(w(k)) < tol * r0Norm || iters == maxIters);
if (stop || k == restart) { if (stop || k == restart) {
// solve upper triangular system // solve upper triangular system
VectorType y = w.head(k); VectorType y = w.head(k);
H.topLeftCorner(k, k).template triangularView < Eigen::Upper > ().solveInPlace(y); H.topLeftCorner(k, k).template triangularView < Eigen::Upper > ().solveInPlace(y);
// use Horner-like scheme to calculate solution vector // use Horner-like scheme to calculate solution vector
VectorType x_new = y(k - 1) * VectorType::Unit(m, k - 1); VectorType x_new = y(k - 1) * VectorType::Unit(m, k - 1);
// apply Householder reflection H_{k} to x_new // apply Householder reflection H_{k} to x_new
x_new.tail(m - k + 1).applyHouseholderOnTheLeft(H.col(k - 1).tail(m - k), tau.coeffRef(k - 1), workspace.data()); x_new.tail(m - k + 1).applyHouseholderOnTheLeft(H.col(k - 1).tail(m - k), tau.coeffRef(k - 1), workspace.data());
for (int i = k - 2; i >= 0; --i) { for (int i = k - 2; i >= 0; --i) {
x_new += y(i) * VectorType::Unit(m, i); x_new += y(i) * VectorType::Unit(m, i);
// apply Householder reflection H_{i} to x_new // apply Householder reflection H_{i} to x_new
x_new.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data()); x_new.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
} }
x += x_new; x += x_new;
if (stop) { if (stop) {
return true; return true;
} else { } else {
k=0; k=0;
// reset data for a restart r0 = rhs - mat * x; // reset data for restart
VectorType p0=mat*x; const VectorType p0 = rhs - mat*x;
VectorType p1=precond.solve(p0); r0 = precond.solve(p0);
r0 = rhs - p1;
// r0_sqnorm = r0.squaredNorm();
w = VectorType::Zero(restart + 1);
H = FMatrixType::Zero(m, restart + 1);
tau = VectorType::Zero(restart + 1);
// generate first Householder vector // clear Hessenberg matrix and Householder data
RealScalar beta; H = FMatrixType::Zero(m, restart + 1);
r0.makeHouseholder(e, tau.coeffRef(0), beta); w = VectorType::Zero(restart + 1);
w(0)=(Scalar) beta; tau = VectorType::Zero(restart + 1);
H.bottomLeftCorner(m - 1, 1) = e;
} // generate first Householder vector
RealScalar beta;
r0.makeHouseholder(e, tau.coeffRef(0), beta);
w(0)=(Scalar) beta;
H.bottomLeftCorner(m - 1, 1) = e;
} }
}
} }