MATLAB Function Reference |
Syntax
x = bicg(A,b) bicg(A,b,tol) bicg(A,b,tol,maxit) bicg(A,b,tol,maxit,M) bicg(A,b,tol,maxit,M1,M2) bicg(A,b,tol,maxit,M1,M2,x0) [x,flag] = bicg(A,b,...) [x,flag,relres] = bicg(A,b,...) [x,flag,relres,iter] = bicg(A,b,...) [x,flag,relres,iter,resvec] = bicg(A,b,...)
Description
x = bicg(A,b)
attempts to solve the system of linear equations A*x = b
for x
. The n
-by-n
coefficient matrix A
must be square and should be large and sparse. The column vector b
must have length n
. A
can be a function handle afun
such that afun(x,'notransp')
returns A*x
and afun(x,'transp')
returns A'*x
. See Function Handles in the MATLAB Programming documentation for more information.
Parameterizing Functions Called by Function Functions, in the MATLAB Mathematics documentation, explains how to provide additional parameters to the function afun
, as well as the preconditioner function mfun
described below, if necessary.
If bicg
converges, it displays a message to that effect. If bicg
fails to converge after the maximum number of iterations or halts for any reason, it prints a warning message that includes the relative residual norm(b-A*x)/norm(b)
and the iteration number at which the method stopped or failed.
bicg(A,b,tol)
specifies the tolerance of the method. If tol
is []
, then bicg
uses the default, 1e-6
.
bicg(A,b,tol,maxit)
specifies the maximum number of iterations. If maxit
is []
, then bicg
uses the default, min(n,20)
.
bicg(A,b,tol,maxit,M) and bicg(A,b,tol,maxit,M1,M2)
use the preconditioner M
or M = M1*M2
and effectively solve the system inv(M)*A*x = inv(M)*b
for x
. If M
is []
then bicg
applies no preconditioner. M
can be a function handle mfun
such that mfun(x,'notransp')
returns M\x
and mfun(x,'transp')
returns M'\x
.
bicg(A,b,tol,maxit,M1,M2,x0)
specifies the initial guess. If x0
is []
, then bicg
uses the default, an all-zero vector.
[x,flag] = bicg(A,b,...)
also returns a convergence flag.
Whenever flag
is not 0
, the solution x
returned is that with minimal norm residual computed over all the iterations. No messages are displayed if the flag
output is specified.
[x,flag,relres] = bicg(A,b,...)
also returns the relative residual norm(b-A*x)/norm(b)
. If flag
is 0
, relres <= tol
.
[x,flag,relres,iter] = bicg(A,b,...)
also returns the iteration number at which x
was computed, where 0 <= iter <= maxit
.
[x,flag,relres,iter,resvec] = bicg(A,b,...)
also returns a vector of the residual norms at each iteration including norm(b-A*x0)
.
Examples
n = 100; on = ones(n,1); A = spdiags([-2*on 4*on -on],-1:1,n,n); b = sum(A,2); tol = 1e-8; maxit = 15; M1 = spdiags([on/(-2) on],-1:0,n,n); M2 = spdiags([4*on -on],0:1,n,n); x = bicg(A,b,tol,maxit,M1,M2);
This example replaces the matrix A
in Example 1 with a handle to a matrix-vector product function afun
. The example is contained in an M-file run_bicg
that
bicg
with the function handle @afun
as its first argument.
afun
as a nested function, so that all variables in run_bicg
are available to afun
.
The following shows the code for run_bicg
:
function x1 = run_bicg n = 100; on = ones(n,1); A = spdiags([-2*on 4*on -on],-1:1,n,n); b = sum(A,2); tol = 1e-8; maxit = 15; M1 = spdiags([on/(-2) on],-1:0,n,n); M2 = spdiags([4*on -on],0:1,n,n); x1 = bicg(@afun,b,tol,maxit,M1,M2); function y = afun(x,transp_flag) if strcmp(transp_flag,'transp') % y = A'*x y = 4 * x; y(1:n-1) = y(1:n-1) - 2 * x(2:n); y(2:n) = y(2:n) - x(1:n-1); elseif strcmp(transp_flag,'notransp') % y = A*x y = 4 * x; y(2:n) = y(2:n) - 2 * x(1:n-1); y(1:n-1) = y(1:n-1) - x(2:n); end end end
Example 3. This example demonstrates the use of a preconditioner. Start with A = west0479
, a real 479-by-479 sparse matrix, and define b
so that the true solution is a vector of all ones.
You can accurately solve A*x = b
using backslash since A
is not so large.
Now try to solve A*x = b
with bicg
.
The value of flag
indicates that bicg
iterated the default 20 times without converging. The value of iter
shows that the method behaved so badly that the initial all-zero guess was better than all the subsequent iterates. The value of relres
supports this: relres = norm(b-A*x)/norm(b
) = norm(b)/norm(b)
= 1
. You can confirm that the unpreconditioned method oscillates rather wildly by plotting the relative residuals at each iteration.
Now, try an incomplete LU factorization with a drop tolerance of 1e-5
for the preconditioner.
[L1,U1] = luinc(A,1e-5); Warning: Incomplete upper triangular factor has 1 zero diagonal. It cannot be used as a preconditioner for an iterative method. nnz(A), nnz(L1), nnz(U1) ans = 1887 ans = 5562 ans = 4320
The zero on the main diagonal of the upper triangular U1
indicates that U1
is singular. If you try to use it as a preconditioner,
[x,flag,relres,iter,resvec] = bicg(A,b,1e-6,20,L1,U1) flag = 2 relres = 1 iter = 0 resvec = 7.0557e+005
the method fails in the very first iteration when it tries to solve a system of equations involving the singular U1
using backslash. bicg
is forced to return the initial estimate since no other iterates were produced.
Try again with a slightly less sparse preconditioner.
This time U2
is nonsingular and may be an appropriate preconditioner.
and bicg
converges to within the desired tolerance at iteration number 8. Decreasing the value of the drop tolerance increases the fill-in of the incomplete factors but also increases the accuracy of the approximation to the original matrix. Thus, the preconditioned system becomes closer to inv(U)*inv(L)*L*U*x = inv(U)*inv(L)*b
, where L
and U
are the true LU factors, and closer to being solved within a single iteration.
The next graph shows the progress of bicg
using six different incomplete LU factors as preconditioners. Each line in the graph is labeled with the drop tolerance of the preconditioner used in bicg
.
See Also
bicgstab
, cgs
, gmres
, lsqr
, luinc
, minres
, pcg
, qmr
, symmlq
function_handle
(@
), mldivide
(\
)
References
[1] Barrett, R., M. Berry, T. F. Chan, et al., Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods, SIAM, Philadelphia, 1994.
betaln | bicgstab |
© 1994-2005 The MathWorks, Inc.