О выборе метода решения систем уравнений
Каждый из рассмотренных методов имеет свои достоинства и недостатки. В частности, метод Гаусса позволяет получить решение за конечное число шагов. Для этого требуется выполнить n(n2 + 3n – 1)/3 операций умножения и деления и n(n – 1)(2n + 5)/6 операций сложения и вычитания, количество которых при больших порядках системы (n > 100) можно принять равным n3/3 в обоих случаях. Однако его методические ошибки, связанные с размером разрядной сетки вычислений, резко нарастают с увеличением порядка системы и не позволяют применять его для систем высоких порядков без использования специальных приёмов.
Итерационные методы позволяют получать решение систем бóльшего порядка. Для выполнения каждой итерации с их помощью необходимо сделать n(n + 1) операций умножения и деления и столько же операций сложения и вычитания. При больших порядках системы уравнений (n > 100) их количество можно принять равным n2. Из сравнения трудоёмкости итерационных методов и метода Гаусса следует оценка, которой можно руководствоваться при выборе метода решения системы при необходимости его многократного нахождения. Если количество итераций, требуемое для получения решения системы итерационными методами, не превышает n/3, то выгоднее применять их, а не метод Гаусса. Однако здесь следует помнить, что итерационные методы требуют, чтобы матрица системы обладала определёнными свойствами, обеспечивающими их сходимость. Необходимо также отметить, что выполнение этих требований часто не гарантирует высокой скорости их сходимости.
Пример решения на пэвм в среде Matlab
Решить заданную ниже систему линейных алгебраических уравнений
.
Сначала воспользуемся методом Гаусса в виде LU-разложения. Этот алгоритм запрограммирован в Matlab’е и вызывается с помощью функции linsolve. У этой функции обязательными являются два аргумента: матрица A системы уравнений и вектор b её правых частей, а возвращает она вектор решения x. Обращение к ней производится командой
x=linsolve(A,b).
Для ускорения решения и уменьшения его погрешности можно задать третий параметр opts, определяющий вид матрицы системы
x=linsolve(A,b,opts).
Для этого перед вызовом функции linsolve надо заполнить структуру opts с информацией о матрице со следующими полями:
SYM – матрица системы – симметричная;
LT – матрица системы – нижняя треугольная;
UT – матрица системы – верхняя треугольная;
UHESS – матрица системы – хессенбергова (такая матрица представляет собой почти треугольную матрицу, у которой сохранена одна диагональ ниже (выше) главной, а элементы ниже (выше) этой диагонали равны нулю);
POSDEF – матрица системы – симметричная, положительно определенная;
RECT – матрица системы – прямоугольная;
TRANSA – предполагается решать систему с матрицей, транспонированной заданной.
Каждое поле может принимать значение либо true, либо false. Например, для симметричной и положительно определенной матрицы следует задать:
opts.SYM=true; opts.LT=false; opts.UT=false;
opts.UHESS=false; opts.POSDEF=true;
opts.RECT=false; opts.TRANSA=false;
Разумеется, не все комбинации значений полей допустимы, например матрица не может быть треугольной и в то же самое время симметричной и положительно определенной.
После получения решения системы в программе с обращением к функции linsolve следует оценить его погрешность. Для этого надо умножить матрицу А на полученное решение, вычислить вектор невязки правых частей и решить систему с A и новым вектором правых частей. Для вывода более 4 знаков после запятой можно применить оператор format, при этом для вывода значений векторов решения и его погрешности после команд по их вычислению не надо ставить точку с запятой.
Ниже показан текст программы, реализующей вышеприведённые рассуждения.
format long
A=[ 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0;
0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0;
1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0;
0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0;
0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0;
0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0;
0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0;
0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0;
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0];
b=[ 1.0; 1.0; 1.0; 1.0; 5.0; 5.0; 1.0; 1.0; 1.0; 1.0];
k=rcond(A); расчет обусловленности матрицы
x=linsolve(A,b)
b1=A*x умножение матрицы системы на полученное решение
db=b-b1 вычисление вектора невязок правых частей
dx=linsolve(A,db) расчет вектора погрешности решения
Запуск m-файла с этой программой на выполнение позволяет получить следующий результат:
x =
0.153659522846745
0.104865884890147
0.252459900256099
0.275643617738240
0.712360156355304
0.712360156355304
0.275643617738240
0.252459900256099
0.104865884890147
0.153659522846745
b1 =
1.000000000000000
1.000000000000000
1.000000000000000
1.000000000000000
4.999999999999999
4.999999999999998
1.000000000000000
1.000000000000001
1.000000000000000
1.000000000000000
db =
1.0e-014 * вывод произведен в форме 1.0·10–14
0
0
0.022204460492503
0.044408920985006
0.088817841970013
0.177635683940025
-0.022204460492503
-0.066613381477509
0.033306690738755
0.022204460492503
dx =
1.0e-015 * вывод произведен в форме 1.0·10–15
-0.009313105605458
0.016293998889338
0.024154034084358
0.122812913012378
0.115273834910054
0.240733790859356
-0.015045409146115
-0.032089008593153
0.007780287279495
0.021613999610605
Норма вектора погрешности решения, сохранённого в массиве dx, равна 0.2407·10–15. Поэтому абсолютная погрешность полученного решения системы уравнений, хранящегося в массивеx, не превосходит 0.2407·10–15, а его относительная погрешность, принимая во внимание то, что норма вектора решения равна 0.7124, будет не больше, чем 0.3379·10–15≈ 3.4·10–14%.
Если заданную систему линейных алгебраических уравнений требуется решить методом итераций, то сначала её надо преобразовать к виду
.
и подобрать
параметр релаксации так, чтобы выполнялось условие сходимости
метода
.
Для подбора параметра можно применить приём отличный от указанного выше. Он основан на использовании встроенной в Matlab функции norm, которая вычисляет абсолютную норму матрицы
.
С
её помощью можно построим график функции
для значений,
например от –1 до 1, и подобрать его
требуемое значение.
Программа, реализующая эти действия, может быть записана в следующем виде
A=[ 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0;
0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0;
1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0;
0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0;
0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0;
0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0;
0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0;
0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0;
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0];
b=[ 1.0; 1.0; 1.0; 1.0; 5.0; 5.0; 1.0; 1.0; 1.0; 1.0];
E=eye(10); задание единичной матрицы E
x=[-1:0.01:1];
for i=1:201
y(i)=norm(E-x(i)*A);
end
plot(x,y),grid
В качестве результата работы такой программы получается график, представленный на рис.1.
Рис.1.
С его помощью можно выбрать = 0.15, при котором выполняется условие сходимости метода итераций.
Теперь можно непосредственно решать исходную систему уравнений. В соответствии с алгоритмом метода простых итераций реализующая его программа будет иметь вид
format long
A=[ 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0;
0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0, 0.0;
1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0, 0.0;
0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0, 0.0;
0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0, 0.0;
0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0, 1.0;
0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0,-2.0;
0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0, 0.0;
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,-2.0, 0.0, 8.0];
b=[ 1.0; 1.0; 1.0; 1.0; 5.0; 5.0; 1.0; 1.0; 1.0; 1.0];
E=eye(10); задание единичной матрицы E
D=E-0.15*A; вычисление матрицы преобразованной системы
nD=norm(D); вычисление нормы преобразованной системы
p=0.15*b; вычисление правой части преобразованной системы
x=zeros(10,1); задание нулевого приближения вектора решения – нулевого вектора
k=1;
x=(W*x+b); первая итерация
Eotn=nD/(1-nD); вычисление относительной погрешности
while Eotn>1.0e-15 начало итераций, погрешность решения – 10–15
k=k+1;
x=(W*x+b);
Eotn=nD^k/(1-nD^k);
end
x=x вывод результата решения системы в командное окно
Ниже приведён результат выполнения программы.
x =
0.153659522846745
0.104865884890147
0.252459900256099
0.275643617738239
0.712360156355304
0.712360156355304
0.275643617738239
0.252459900256099
0.104865884890147
0.153659522846745
Полученое решение совпадает с ранее найденным с помощью функции Matlab’аlinsolveс точностью до 10–15.