Xreferat.com » Рефераты по математике » Итерационные методы решения систем нелинейных уравнений

Итерационные методы решения систем нелинейных уравнений

линейных частей уравнений;

G(X) - вектор-функция нелинейных частей уравнений.

Выберем некоторый начальный вектор X(0) и построим итерационный процесс в виде

A X(k+1)=-G(X(k)).

Для выполнения одной итерации таким методом необходимо решать систему линейных уравнений, у которой вектором свободных членов будут нелинейные части функций fi(X). Причем поскольку матрица A остается неизменной при всех итерациях, то для решения СЛАУ можно использовать специальные алгоритмы, предусматривающие возможность преобразования только столбца свободных членов.


3.2 Метод релаксаций

Перепишем систему в виде

X=X+ F(X),

где  - некоторая константа, и построим итерационный процесс по схеме

X(k+1) = X(k) +  F(X(k)).

Параметр  должен быть таким, чтобы в окрестности решения выполнялось достаточное условие сходимости

||Е+  W|| < 1,

где E- единичная матрица.

На практике выполнение этого условия достаточно сложно проверить, поэтому значение параметра  выбирают пробным путем, проверяя выполнение необходимого условия сходимости после выполнения каждой итерации

||X(k)-X(k-1)||<||X(k-1)-X(k-2)||.

Если окажется, что на какой-либо итерации это условие не выполняется, то необходимо изменить значение параметра .

3.3 Метод градиентного спуска

Пусть имеем систему уравнений  (А)

Предположим, что функции  действительные и непрерывно дифференцированные в их общей области определения. Рассмотрим функцию

 (В)

Очевидно, что каждое решение системы (А) превращает в ноль функцию U(x); наоборот, числа , для которых функция U(x) равняется нулю, является корнем системы (А).

Предположим, что система имеет лишь изолированное решение, которое представляет собой точку строго минимума функции U(x) в n-мерном пространстве .

Пусть x - вектор системы (А) и x0 - его нулевое приближение. Через точку x0 проведем поверхность уровня функции U(x). Если точка x0 довольно близка к корню x, то при наших предположениях поверхность уровня

 

U(x)= U(x0)

будет похожа на эллипсоид.

Из точки x0 движемся по нормали к поверхности U(x)= U(x0) до тех пор, пока эта нормаль не затронет в некоторой точке x1 какой-то другой поверхности уровня U(x)= U(x1).

Потом, отправляясь от точки x1, снова движемся по нормали к поверхности уровня U(x)= U(x1) до тех пор, пока эта нормаль не затронет в некоторой точке x2 новой поверхности уровня U(x)= U(x2), и т.д.

Поскольку U(x0)>U(x1)>U(x2)>..., то, двигаясь таким путем, мы быстро приближаемся к точке с наименьшим значением U ("дно ямы"), что отвечает искомому решению исходной системы. Обозначим через


градиент функции U(x).

Находить нужное решение будем по формуле:

Остается определить множители . Для этого рассмотрим скалярную функцию

Функция F(l) дает изменение уровня функции U вдоль соответствующей нормали к поверхности уровня в точке xp. Множитель  надо выбрать таким образом, чтобы F(l) имела минимум. Беря производную по l и приравнивая ее нулю, получаем уравнение

.

Наименьший положительный корень этого уравнения и даст нам значение .

Будем считать, что l - малая величина, квадратом и высшими степенями которой можно пренебрегать. Имеем:

Раскладывая функции  за степенями l с точностью до линейных членов, получим:

,

где .

Отсюда

Итак,

, где

- матрица Якоби вектор- функции f.

Дальше, имеем:

.

Отсюда


,

где W'(x) - транспонированная матрица Якоби.

Поэтому окончательно

,

причем

.


3. Программная реализация итерационных методов

Реализация алгоритмов итерационных методов решения систем нелинейных уравнений будет показана на примере системы:

3.1 Метод простых итераций

Приведём систему к виду:

Проверим условие сходимости метода простых итераций.

Для этого построим матрицу Якоби


> f1:=0.1-x0^2+2*y0*z0;

f2:=-0.2+y0^2-3*x0*z0;

f3:=0.3-z0^2-2*x0*y0;

> f1x:=diff(f1,x0):

> f1y:=diff(f1,y0):

> f1z:=diff(f1,z0):

> f2x:=diff(f2,x0):

> f2y:=diff(f2,y0):

> f2z:=diff(f2,z0):

> f3x:=diff(f3,x0):

> f3y:=diff(f3,y0):

> f3z:=diff(f3,z0):

> A:=<<f1x|f1y|f1z>,<f2x|f2y|f2z>,<f3x|f3y|f3z>>;

И найдём ей обратную, норму обратной матрицы сначала в общем виде:

> A1:=MatrixInverse(A);


> norma:=MatrixNorm(A1,1);

Найдём значения  при которых норма обратной матрицы Якоби меньше единицы.

> x0:=1; y0:=1; z0:=1;

> norma;

Это означает, что по формулам


последовательность итераций будет сходиться к решению системы уравнений.

Построим итерационную последовательность

> restart;

> with(LinearAlgebra):

> x0:=0:

y0:=0:

z0:=0:

> x:=0.1-x0^2+2*y0*z0;

y:=-0.2+y0^2-3*x0*z0;

z:=0.3-z0^2-2*x0*y0;

i:=1;

> while (abs(x-x0)>0.0001)and(abs(y-y0)>0.0001)and(abs(z-z0)>0.0001) do

x0:=x:

y0:=y:

z0:=z:

x:=0.1-x0^2+2*y0*z0;

y:=-0.2+y0^2-3*x0*z0;

z:=0.3-z0^2-2*x0*y0;

i:=i+1;

end do:

Получили ответ:

Количество итераций:

Погрешность решения:

Отсюда можно получить коэффициент сжатия последовательности:

При

> P:= 0.3*q^22/(1-q)-0.0001;

> q:= fsolve(P);

Таким образом можно сказать, что было построено сжимающее отображение, для которого выполняется условие Липшица

Текст программы:

procedure TForm1.Button3Click(Sender: TObject);

var i:integer;

x0,y0,z0,x,y,z,eps: real;

begin

x0:=StrToFloat(Edit1.Text);

y0:=StrToFloat(Edit2.text);

z0:=StrToFloat(Edit3.Text);

eps:=StrToFloat(Edit20.Text);

i:=1;

x:=0.1-x0*x0+2*y0*z0;

y:=-0.2+y0*y0-3*x0*z0;

z:=0.3-z0*z0-2*x0*y0;

repeat

i:=i+1;

x0:=x;

y0:=y;

z0:=z;

x:=0.1-x0*x0+2*y*z;

y:=-0.2+y0*y0-3*x0*z0;

z:=0.3-z0*z0-2*x0*y0;

until ((abs(x-x0)<eps)and(abs(y-y0)<eps)and(abs(z-z0)<eps));

Edit8.Text:=FloatToStr(x);

Edit9.Text:=FloatToStr(y);

Edit10.Text:=FloatToStr(z);

Edit11.Text:=IntToStr(i);

end;

Преобразование Эйткена на примере метода простых итереций:

> restart;

> x0:=0:

y0:=0:

z0:=0:

> f1:=0.1-x0^2+2*y0*z0;

f2:=-0.2+y0^2-3*x0*z0;

f3:=0.3-z0^2-2*x0*y0;

ff1:=0.1-f1^2+2*f2*f3;

ff2:=-0.2+f2^2-3*f1*f3;

ff3:=0.3-f3^2-2*f1*f2;

x:=(x0*ff1-f1^2)/(ff1-2*f1+x0);

y:=(y0*ff2-f2^2)/(ff2-2*f2+y0);

z:=(z0*ff3-f3^2)/(ff3-2*f3+z0);

i:=1;

while (abs(x-x0)>0.0001)do

x0:=x:

y0:=y:

z0:=z:

f1:=0.1-x0^2+2*y0*z0;

f2:=-0.2+y0^2-3*x0*z0;

f3:=0.3-z0^2-2*x0*y0;

ff1:=0.1-f1^2+2*f2*f3;

ff2:=-0.2+f2^2-3*f1*f3;

ff3:=0.3-f3^2-2*f1*f2;

x:=(x0*ff1-f1^2)/(ff1-2*f1+x0);

y:=(y0*ff2-f2^2)/(ff2-2*f2+y0);

z:=(z0*ff3-f3^2)/(ff3-2*f3+z0):

i:=i+1;

end do:

Получили ответ:

Количество итераций:

3.2 Метод градиентного спуска

Построим функцию:

> U:=(0.1-x^2+2*y*z-x)^2+(-0.2+y^2-3*x*z-y)^2+(0.3-z^2-2*x*y-z)^2;

Найдём градиент функции:

> Ux:= diff(U,x);

Uy:= diff(U,y);

Uz:= diff(U,z);

Выберем начальное приближение и построим итерационную последовательность:


> x:=0;

y:=0;

z:=0;

> N1:=2*(.1-x^2+2*y*z-x)*(-2*x-1)-6*(-.2+y^2-3*x*z-y)*z-4*(.3-z^2-2*x*y-z)*y;

> N2:=4*(.1-x^2+2*y*z-x)*z+2*(-.2+y^2-3*x*z-y)*(2*y-1)-4*(.3-z^2-2*x*y-z)*x;

> N3:=4*(.1-x^2+2*y*z-x)*y-6*(-.2+y^2-3*x*z-y)*x+2*(.3-z^2-2*x*y-z)*(-2*z-1);

> x:=x-lambda*N1;

y:=y-lambda*N2;

z:=z-lambda*N3;

i:=1;

> N1:=2*(.1-x^2+2*y*z-x)*(-2*x-1)-6*(-.2+y^2-3*x*z-y)*z-4*(.3-z^2-2*x*y-z)*y;

N2:=4*(.1-x^2+2*y*z-x)*z+2*(-.2+y^2-3*x*z-y)*(2*y-1)-4*(.3-z^2-2*x*y-z)*x;

N3:=4*(.1-x^2+2*y*z-x)*y-6*(-.2+y^2-3*x*z-y)*x+2*(.3-z^2-2*x*y-z)*(-2*z-1);

x:=x-lambda*N1;

y:=y-lambda*N2;

z:=z-lambda*N3;

> while (abs(N3)>0.0001) do

N1:=2*(.1-x^2+2*y*z-x)*(-2*x-1)-6*(-.2+y^2-3*x*z-y)*z-4*(.3-z^2-2*x*y-z)*y:

N2:=4*(.1-x^2+2*y*z-x)*z+2*(-.2+y^2-3*x*z-y)*(2*y-1)-4*(.3-z^2-2*x*y-z)*x:

N3:=4*(.1-x^2+2*y*z-x)*y-6*(-.2+y^2-3*x*z-y)*x+2*(.3-z^2-2*x*y-z)*(-2*z-1):

x:=x-lambda*N1:

y:=y-lambda*N2:

z:=z-lambda*N3:

i:=i+1:

end do:

Получили ответ:

Количество итераций и данным шагом :

Текст программы:

procedure TForm1.Button1Click(Sender: TObject);

const

lambda=-0.0001;

n=3;

type mas=array[1..n]of real;

var //x,y,z:real;

Xp,nab,v:mas;

i:integer;

eps:real;

function max(x:mas):real;

var s:real;

i:integer;

begin s:=abs(x[1]);

for i:=2 to 4 do if abs(x[i])>s then s:=abs(x[i]);

max:=s;

end;

Procedure add(var a,b:mas);

var

i:integer;

begin

for i:=1 to n do

begin

a[i]:=a[i]+b[i];

end;

end;

Procedure mult(a:mas;c:real;var v:mas);

var

i:integer;

begin

for i:=1 to n do

begin

v[i]:=a[i]*c;

end;

end;

procedure nabla(Xp:mas; var nab:mas);

begin

nab[1]:=2*(0.1-xp[1]*xp[1]+2*xp[2]*xp[3]-xp[1])*(-2*xp[1]-1)-6*(-0.2+xp[2]*xp[2]-3*xp[1]*xp[3]-xp[2])*xp[3]-4*(0.3-xp[3]*xp[3]-2*xp[1]*xp[2]-xp[3])*xp[2];

nab[2]:=4*(0.1-xp[1]*xp[1]+2*xp[2]*xp[3]-xp[1])*xp[3]+2*(-0.2+xp[2]*xp[2]-3*xp[1]*xp[3]-xp[2])*(2*xp[2]-1)-4*(0.3-xp[3]*xp[3]-2*xp[1]*xp[2]-xp[3])*xp[1];

nab[3]:=4*(0.1-xp[1]*xp[1]+2*xp[2]*xp[3]-xp[1])*xp[2]-6*(-0.2+xp[2]*xp[2]-3*xp[1]*xp[3]-xp[2])*xp[1]+2*(0.3-xp[3]*xp[3]-2*xp[1]*xp[2]-xp[3])*(-2*xp[3]-1);

end;

begin

Xp[1]:=StrToFloat(Edit1.Text);

Xp[2]:=StrToFloat(Edit2.Text);

Xp[3]:=StrToFloat(Edit3.Text);

eps:=StrToFloat(Edit20.Text);

repeat

nabla(Xp,nab);

mult(nab,lambda,v);

add(Xp,v);

i:=i+1;

until max(nab)<eps;

Edit4.Text:=FloatToStr(Xp[1]);

Edit5.Text:=FloatToStr(Xp[2]);

Edit6.Text:=FloatToStr(Xp[3]);

Edit7.Text:=IntToStr(i);

//Edit21.Text:=IntToStr(kk);

end;

procedure TForm1.Button3Click(Sender: TObject);

var i:integer;

x0,y0,z0,x,y,z,eps: real;

begin

x0:=StrToFloat(Edit1.Text);

y0:=StrToFloat(Edit2.text);

z0:=StrToFloat(Edit3.Text);

eps:=StrToFloat(Edit20.Text);

i:=1;

x:=0.1-x0*x0+2*y0*z0;

y:=-0.2+y0*y0-3*x0*z0;

z:=0.3-z0*z0-2*x0*y0;

repeat

i:=i+1;

x0:=x;

y0:=y;

z0:=z;

x:=0.1-x0*x0+2*y*z;

y:=-0.2+y0*y0-3*x0*z0;

z:=0.3-z0*z0-2*x0*y0;

until ((abs(x-x0)<eps)and(abs(y-y0)<eps)and(abs(z-z0)<eps));

Edit8.Text:=FloatToStr(x);

Edit9.Text:=FloatToStr(y);

Edit10.Text:=FloatToStr(z);

Edit11.Text:=IntToStr(i);

end;

3.3 Метод Ньютона

Строим матрицу Якоби:

> restart;

> with(LinearAlgebra):

> f1:=0.1-x0^2+2*y0*z0-x0;

> f2:=-0.2+y0^2-3*x0*z0-y0;

> f3:=0.3-z0^2-2*x0*y0-z0;

> f1x:=diff(f1,x0);

> f1y:=diff(f1,y0);

> f1z:=diff(f1,z0);

> f2x:=diff(f2,x0);

> f2y:=diff(f2,y0);

> f2z:=diff(f2,z0);

> f3x:=diff(f3,x0);

> f3y:=diff(f3,y0);

> f3z:=diff(f3,z0);

> A:=<<f1x|f1y|f1z>,<f2x|f2y|f2z>,<f3x|f3y|f3z>>;

Выбираем начальное приближение, близкое к уже известному нам корню и строим последовательность:

> x0:=0;y0:=0;z0:=0;

> A:=A;

> A1:=A^(-1);

> f:=<f1,f2,f3>;

> X0:=<x0,y0,z0>:

> X:=Add(X0,(Multiply(A1,f)),1,-1);

> X0:=X;

> x0:=X[1];y0:=X[2];z0:=X[3];

> A:=<<f1x|f1y|f1z>,<f2x|f2y|f2z>,<f3x|f3y|f3z>>;

> A1:=A^(-1);

> f:=<f1,f2,f3>;

> X:=Add(X0,(Multiply(A1,f)),1,-1);

> i:=2:

> while (Norm(f))>0.0001 do

X0:=X;

x0:=X[1];y0:=X[2];z0:=X[3];

A:=<<f1x|f1y|f1z>,<f2x|f2y|f2z>,<f3x|f3y|f3z>>;

A1:=A^(-1);

f:=<f1,f2,f3>;

X:=Add(X0,(Multiply(A1,f)),1,-1);

i:=i+1;

end do:

> X:=X;

Получили ответ:

Количество итераций:

Текст программы

procedure TForm1.Button4Click(Sender: TObject);

type mas=array[1..3]of real;

matr=array[1..3,1..3]of real;

var a,a1:matr;

i,j:integer;

x,y,z,eps:real;

f,xk,xkk,temp:mas;

procedure jacobi(x,y,z:real; var a:matr);

begin

a[1,1]:=-2*x-1;

a[1,2]:=2*z;

a[1,3]:=2*y;

a[2,1]:=-3*z;

a[2,2]:=2*y-1;

a[2,3]:=-3*x;

a[3,1]:=-2*y;

a[3,2]:=-2*x;

a[3,3]:=-2*z-1;

end;

procedure inverse(a:matr;var a1:matr);

var i,j:integer;

det:real;

s:matr;

begin

det:=a[1,1]*a[2,2]*a[3,3]+a[2,1]*a[3,2]*a[1,3]+a[1,2]*a[2,3]*a[3,1]-a[3,1]*a[2,2]*a[1,3]-a[3,2]*a[2,3]*a[1,1]-a[2,1]*a[1,2]*a[3,3];

s[1,1]:=a[2,2]*a[3,3]-a[2,3]*a[3,2];

s[1,2]:=-a[1,2]*a[3,3]+a[1,3]*a[3,2];

s[1,3]:=a[1,2]*a[2,3]-a[1,3]*a[2,2];

s[2,1]:=-a[2,1]*a[3,3]+a[2,3]*a[3,1];

s[2,2]:=a[1,1]*a[3,3]-a[1,3]*a[3,1];

s[2,3]:=-a[1,1]*a[2,3]+a[1,3]*a[2,1];

s[3,1]:=a[2,1]*a[3,2]-a[2,2]*a[3,1];

s[3,2]:=-a[1,1]*a[3,2]+a[1,2]*a[3,1];

s[3,3]:=a[1,1]*a[2,2]-a[1,2]*a[2,1];

for i:=1 to 3 do

for j:=1 to 3 do

a1[i,j]:=(1/det)*s[i,j];

end;

procedure fx(x,y,z:real; var f:mas);

begin

f[1]:=-x-x*x+2*y*z+0.1;

f[2]:=-y+y*y-3*x*z-0.2;

f[3]:=-z-z*z-2*x*y+0.3;

end;

procedure minus(x,y:mas; var z:mas);

var i:integer;

begin

for i:=1 to 3 do

z[i]:=x[i]-y[i];

end;

function max(f:mas):real;

var p:real;

i:integer;

begin

p:=0;

for i:=1 to 3 do

if abs(f[i])>p then p:=abs(f[i]);

max:=p;

end;

procedure mult(a:matr;b:mas;var c:mas);

begin

c[1]:=a[1,1]*b[1]+a[1,2]*b[2]+a[1,3]*b[3];

c[2]:=a[2,1]*b[1]+a[2,2]*b[2]+a[2,3]*b[3];

c[3]:=a[3,1]*b[1]+a[3,2]*b[2]+a[3,3]*b[3];

end;

begin

xk[1]:=StrToFloat(Edit1.Text);

xk[2]:=StrToFloat(Edit2.Text);

xk[3]:=StrToFloat(Edit3.Text);

eps:=StrToFloat(Edit20.Text);

i:=0;

repeat

fx(xk[1],xk[2],xk[3],f);

jacobi(xk[1],xk[2],xk[3],a);

inverse(a,a1);

mult(a1,f,temp);

minus(xk,temp,xk);

i:=i+1;

until max(f)<eps;

Edit12.Text:=FloatToStr(xk[1]);

Edit13.Text:=FloatToStr(xk[2]);

Edit14.Text:=FloatToStr(xk[3]);

Edit15.Text:=IntToStr(i);

end;

3.4 Модифицированный метод Ньютона

Аналогично методу Ньютона построим матрицу Якоби для данной системы уравнений, выберем начальное приближение заведомо близко к решению, построим последовательность:

> with(LinearAlgebra):

> f1x:=diff(f1,x0);

> f1y:=diff(f1,y0);

> f1z:=diff(f1,z0);

> f2x:=diff(f2,x0);

> f2y:=diff(f2,y0);

> f2z:=diff(f2,z0);

> f3x:=diff(f3,x0);

> f3y:=diff(f3,y0);

> f3z:=diff(f3,z0);

> A:=<<f1x|f1y|f1z>,<f2x|f2y|f2z>,<f3x|f3y|f3z>>;

> x0:=0;y0:=0;z0:=0;

> A:=A;

> A1:=A^(-1);

> f:=<f1,f2,f3>;

> X0:=<x0,y0,z0>;

> X:=Add(X0,(Multiply(A1,f)),1,-1);

> X0:=X;

> x0:=X[1];y0:=X[2];z0:=X[3];

> f:=<f1,f2,f3>;

> i:=1;

> while (Norm(f))>0.0001 do

X0:=X;

x0:=X[1];y0:=X[2];z0:=X[3];

f:=<f1,f2,f3>;

X:=Add(X0,(Multiply(A1,f)),1,-1);

i:=i+1;

end do;

Получили ответ:

Количество итераций:

Текст программы

procedure TForm1.Button2Click(Sender: TObject);

type mas=array[1..3]of real;

matr=array[1..3,1..3]of real;

var x,y,z,ex,ey,ez,eps,b,c,d:real;

r,xk,f,temp:mas;

a,h,w,a1:matr;

i,kk: integer;

procedure jacobi(x,y,z:real; var a:matr);

procedure inverse(a:matr;var a1:matr);

procedure fx(x,y,z:real; var f:mas);

procedure minus(x,y:mas; var z:mas);

function max(f:mas):real;

procedure mult(a:matr;b:mas;var c:mas);

// все процедуры полностью совпадают с описанными выше реализации метода Ньютона

begin

xk[1]:=StrToFloat(Edit1.Text);

xk[2]:=StrToFloat(Edit2.Text);

xk[3]:=StrToFloat(Edit3.Text);

eps:=StrToFloat(Edit20.Text);

i:=0;

jacobi(xk[1],xk[2],xk[3],a);

inverse(a,a1);

repeat

fx(xk[1],xk[2],xk[3],f);

mult(a1,f,temp);

minus(xk,temp,xk);

i:=i+1;

until max(f)<eps;

Edit16.Text:=FloatToStr(xk[1]);

Edit17.Text:=FloatToStr(xk[2]);

Edit18.Text:=FloatToStr(xk[3]);

Edit19.Text:=IntToStr(i);


Выводы

Численное решение нелинейных алгебраических уравнений является сложной и не до конца разрешимой задачей вычислительной математики.

При решении систем нелинейных уравнений иногда поступают следующим образом. Строится функционал, минимум которого достигается в решении системы. Затем, задавши начальное приближение к точке минимума, проводят итерации каким-либо из методов спуска. И таким путём получают удовлетворительное приближение к решению системы. Исходя из этого приближения, проводят уточнения при помощи какого-либо итерационного метода, например метода Ньютона или Пикара.

Поясним причины, вызывающие такое комбинированное применение методов. Область сходимости метода – множество начальных условий, при которых итерации по данному методу сходятся к решению задачи. Применение методов спуска на первоначальном этапе вызвано тем, что они имеют более широкую область сходимости, чем методы специфические для задачи решения системы уравнений.

На нашем примере можно в этом убедиться.

Метод градиентного спуска при начальном приближении даже равном  сходится к решению  . При более отдалённом начальном приближении, например,  приводит к другому решению () из множества решений системы. Как видим, полученные ответы значительно отличаются от первоначального приближения, что свидетельствует о широкой области сходимости метода градиентного спуска. Также заметим, что при разных удачно выбранных начальных приближениях этот метод может привести нас к любому решению системы уравнений. То есть, в построении метода нет привязки только к конкретному решению, он универсален. Однако скорость сходимости линейная, довольно медленная при выборе маленького шага. Поэтому и применяют этот метод первоначально, с относительно большим шагом и низкой точностью конечного решения для сокращения количества итераций при поиске приближения к корню, которое используют далее в других методах.

Метод Ньютона имеет высокую скорость сходимости, поэтому его удобнее применять, когда требуемая точность велика и известно приближённое значение решения. Однако область сходимости значительно уже.

Для метода простых итераций в нашем примере построено такое отображение, которое только при удачно выбранном начальном приближении к корню . При начальном приближении  итерационная последовательность ещё сходится к решению, если взять начальные условия дальше от корня – метод не сходится ни к указанному выше, какому другому решению системы. Исходя из имеющихся данных про точное решение системы нелинейных уравнений, мы строим последовательность. Эта последовательность сходится только с начальным приближением лежащим в окрестности выбранного корня, и только к нему. Несмотря на возможную близость начального приближения к какому-то другому решению, она к нему не сойдётся, в отличие от других итерационных методов. Это говорит о том, что для каждого из множества решений системы нужно строить своё отображение, удовлетворяющее условиям сходимости. В этом проявляется недостаток метода простых итераций. Но если сжимающее отображение построено правильно, то преимущество метода состоит в простоте вычислений.

При модификации метода путём расчёта обратной матрицы Якоби только в начальной точке ведёт также к сужению области сходимости и к значительному увеличению количества итераций по мере выбора начального приближения дальше от точного решения.

Для решения систем нелинейных уравнений можно использовать метод Ньютона, метод простых итераций и др. Методы градиентного спуска и простой итерации имеют линейную сходимость, метод Ньютона - квадратичную, а квазиньютоновские – надлинейную скорость сходимости. Несмотря на то, что квазиньютоновские методы имеют худшую сравнительно с методом Ньютона теоретическую сходимость, они требуют при своей реализации меньшее количество машинных действий. Однако эти самые методы имеют локальную сходимости, то есть сходимость при хорошем начальном приближении. Для получения этого приближения во время решения систем нелинейных уравнений используют методы спуска и комбинируют их с методами, которые имеют большую скорость сходимости.

При применении того или иного метода к системе нелинейных уравнений нужно учитывать особенности постановки задачи и наличие начальных условий.


Список использованной литературы

1.                Бахвалов Н.С., Лапин А.В., Чижонков Е.В. “Численные методы в задачах и упражнениях”. М.: Высшая школа, 2000.

2.                Мышенков В.И., Мышенков Е.В., «Численные методы», учебное пособие,М., – 2001.

3.                Амосов А.А., Дубинский Ю.А., Копченова Н.В. “Вычислительные методы для инженеров”. М.: Высшая школа, 1994.

4.                Самарский А.А., Гулин А.В. «Численные методы».М.: Наука, 1989.

5.                Назаренко Л.Д., «Численные методы», методическое пособие.

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: