Vous êtes sur la page 1sur 8

Examples and Analysis of Fixed Point Iteration

Fixed Point Iteration (or FPI) is a type of analytical tool for finding numerical solutions to certain
non-linear systems of equations. FPI is a very common tool used in physics, engineering, and applied
mathematics or statistics, thus it is of great importance to understand how and when to use FPI. This
discussion will focus on the best way to use FPI in non-linear systems and the non-linear systems that
are appropriate for FPI.
One of the best advantages of FPI is the simplicity with which it can be programmed. While
some methods require advanced computational programming, FPI is very simplistic in its approach to
solving systems. Of course, this does not come without drawbacks. While FPI is simple to use and
programming, it is also inefficient compared to other methods. While this may not be of crucial
importance when dealing with simple systems, such as 3x3 matrices, it does become important when
there are many variables. A system with hundreds of variables can become quite time consuming and
expensive when using FPI. However, FPI is a good place to start when talking about the solution of non-
linear systems and is why this discussion will be focused on the systems for which FPI can be used.
To begin, the MATLAB code given below will be the guideline used for FPI.
As stated earlier, FPI
is simple to program and this shows in the code. This code will be used as the main program when
calculating the solution of a system for the examples that will be discussed later.

function [x,iter] = FPI(x0,G)
% Fixed Point Iteration method applied to a
% system of any size linear equations G(x) = x
epsilon = 0.0001; %define tolerance
maxit = 100; % define value for divergence
xn = x0; x=x0; iter = 0; % load initial guess, set output to trivial in
case while loop fails
[n m] = size(x0);
N = 1;
while (N < maxit)
if (norm(xnp1-xn,inf) < epsilon*norm(xnp1,inf) )

Code provided by Professor Bruce Wade
x=xnp1; iter=N;
end; %if
N = N + 1
xn = xnp1;
disp('Not Successful, Maxit reached without matching tolerance.')
% end function

This code takes an input function G along with an initial guess x0 and uses these to start the
iteration. The tolerance of the code can be changed as needed for whichever value is necessary for the
specific application. Ideally, the tolerance would be as large as possible for complex several variable
systems in order to minimize the cost and time of the computation. The maximum number of iterations
of this code is set to 100. Again, the higher this number, the greater possible cost and time that will be
used. A certain balance is needed when using FPI and certain data, such as tolerance or maximum
iterations, should be known before the calculation should be performed.
As will be shown, the value of the initial guess can be very important in the process of solving
certain systems. For some systems the accuracy of the initial approximation or guess is not as
important as others, but it should be noted that the accuracy of the guess is important for all systems.
Later examples will show that some systems are more sensitive to the initial approximation than others.
The solution is even more important as will be shown. There are certain instances where FPI fails, even
though the solution is simple. This is due to the theorem that dictates whether FPI will work. The
theorem states that if a matrix or vector () is continuous on an interval, and the derivative

() on any point in that interval, there exists a unique solution that is convergent anywhere on
the interval.
However, there are instances where although this theorem is not followed, there is still a
solution to the system, but perhaps with some restrictions. The following example will show such

Shapiro 2011: 51
Example 1:

This graph of the system shows the solution at (0,1). However, the system itself fails FPI. The
theorem states that for FPI to work, all partial derivatives on the interval must have a solution that is
less than 1 divided by the number of dimensions which is referred to as n. More accurately, according to
Burden and Faires, the theorem holds when:



< 1

Burden and Faires 2011: 633
Since the theorem states that every partial on the interval must effectively be less than one, any
component of the partial derivative matrix (or Jacobian) that is not less than

will make the whole

system fail the theorem, and thus, convergence from any initial value. By calculating the Jacobian and
using the interval of -1

1, the theorem fails. However, even though the system does not converge
from any point, if the starting point is chosen close enough to the solution the system will converge. This
happens with the system when the initial guess is x0 = [0,.78]. The answer will end up converging to
(0,1) which is what was expected here.
There are systems that may not satisfy the theorem in one form, but when rearranged will be
agreeable with FPI.
These systems are usually limited to one- or two-dimensional cases, as it would be
time consuming and expensive to rearrange full systems of several dimensions. The example that will be
looked at below will be finding a root of a one-dimensional system that will be shown to have a singular
solution, but only when the theorem is satisfied. This process of solving for this system may seem a bit
simplistic or trivial, but it is intended to be more informative than truly having a real world application.
The system is as follows:

As stated earlier, finding a solution to this solution is more for educational purposes than
anything else. At first, is may look simple enough to rearrange the system to the following:

Further, calculating the partial of this with respect to x gives:


This is continuous, though, when tested on a certain interval

This will end up having a K value which is great than 1, which fails the test for convergence.
Although the rearranged equation does fail the test for convergence, that doesnt necessarily mean that
the original system does not converge. The equation could be rewritten again such as in the case of the
() ( )

Ron 2010: 1
This is the exact same system that we used before, but it is arranged differently this time in an
attempt to satisfy the theorem laid out before. The partial derivative is then calculated to be:


( )

This in MATLAB code is:
function [Gout] = G(x)
x1 = x(1);
Gout1 = (x1+10)^(1/4);
Gout = [Gout1];

When tested on the same interval before, the value of () is less than 1, which then satisfies
the theorem for convergence of any initial guess. This shows that although the system may not converge
in one trial, it may converge in another. Of course, rearranging a system tends to become quite time
consuming in dimension of several variables, it nonetheless is important to realize that a solution may
exist for a system that does not seem to converge. The graph of the solution is found below. This shows
the solution of the original function that was used.

This graph is the graph of the original function before any rearranging so it shows two different
possible solutions. However, the way the function was arranged in solving for the system will only show
one value when calculated through MATLAB. This graph gives a visual aid to how FPI can help solve for
systems of one dimension. Although somewhat trivial, it should be noted that even a one variable
system can be beneficial in learning the nuances of FPI and how it works.
The final example that will be looked at has three dimensions. This example is taken from
Burden and Faires and it shows how a more complicated example will converge.
So far, this discussion
has been limited to examples of one and two dimensions, but these example are mostly educational and
almost trivial in real world applications. Real world systems can have hundreds of variables and be quite
complex. However, a three dimensional case, although somewhat simple, can provide a glimpse of how
FPI works in more complicated systems. The system is as follows:

This system in MATLAB code is given as follows:
function [Gout] = G(x)
x1 = x(1);
x2 = x(2);
x3 = x(3);
Gout1 = 1/3*cos(x2*x3)+1/6 ;
Gout2 = 1/9*sqrt(x1^2+sin(x3)+1.06)-.1;
Gout3 = -1/20*exp(-x1*x2)-(10*pi-3)/60;
Gout = [Gout1;Gout2; Gout3];

This system is tested to see if it has a unique fixed point using the theorem stated earlier. This is
tested on the region
*( ) +
When calculating the Jacobian, we see that the maximum absolute values of the Jacobian matrix
are all less than .283. This means that since

the system will have a unique fixed solution on D.

Burden and Faires 2011:634
Also, the system will converge from any initial guess that is given, so long as it is in D. Using an initial
guess of:

Solving this system using the initial guess provided above will yield the solution:

Through these three examples, it becomes clear how the use of FPI has its benefits and
drawbacks. FPI is a simple effective way in solving systems of nonlinear equations, however, not every
system is able to be solved through FPI. There are certain cases when FPI fails, and use of a different
method, such as Newtons Method or Secant Method are more appropriate. However, FPI is both
education and practical in certain cases. Although FPI is easier to program, its use can be quite restricted
when certain criteria are not met. These criteria can become more difficult to prove as systems get
larger and more complex so FPI should be applied with some discretion.

Burden, Richard L. and J. Douglas Faires. 2011. Numerical Analysis. Boston: Brooks/Cole.

Ron, Amos. 2010 Solving Equations Using Fixed Point Iteration. University of Wisconsin. 1.

Shapiro, Bruce. 2008 Fixed Point Iteration. California State University Northridge. 51.

Wade, Bruce. Fixed Point Iteration [MATLAB]. Available at
(Accessed 15 February 2014)