Прямые методы решения систем линейных алгебраических уравнений
Министерство
образования и науки, молодежи и спорта Украины
Харьковский
национальный университет имени В.Н. Каразина
Лабораторная
работа №2
Прямые
методы решения систем линейных алгебраических уравнений
Выполнила:
студентка группы МП-31
Кальницкая Б.М.
Проверил:
доц. Скорик В.А.
Харьков
2014
Постановка задачи
. Найти решение систем линейных алгебраических
уравнений Ах=b, найти А-1, вычислить det A.
. Методом Гаусса с выбором ведущего
элемента в строке.
. Методом Гаусса с выбором ведущего
элемента в столбце.
3. Методом Гаусса с выбором ведущего
элемента в матрице. На печать вывести исходную матрицу A, вектор b, решение x,
невязку, det A, А-1. Сравнить полученые результаты.. Найти решение систем
линейных алгебраических уравнений Ах=b, вычислить det A.
1. Методом факторизации.
Напечать вывести исходную матрицу A, вектор b,
решение x, невязку, вычислить det A. Сравнить полученые результаты.
Вариант №4
А = ,
b =
Метод Факторизации
Теорема.
Пусть
Тогда А представима единственным образом в виде где
- нижнетреугольная,
-
верхнетреугольная;
.
При этом решение сводится
к решению двух систем
Листинг программы
#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <math.h>namespace
std;int n = 4;main()
{i = 0, j = 0, k = 0, m = 0;A[n][n],
B[n][n], C[n][n], f[n], x[n], y[n], r[n], Ax[n], max = -1;<< " Our
matrix A is: " << endl;(i = 0; i<n; i++)
{(j = 0; j<n; j++)
{[0][0] = 0.11;[0][1] = -0.17;[0][2]
= 0.72;[0][3] = -0.34;[1][0] = 0.81;[1][1] = 0.12;[1][2] = -0.91;[1][3] =
0.17;[2][0] = 0.17;[2][1] = -0.18;[2][2] = 1;[2][3] = 0.28;[3][0] = 0.13;[3][1]
= 0.17;[3][2] = -0.99;[3][3] = 0.35;[i][j] = 0;[i][j] = 0;[i] = 0;[i] =
0;(" %.4f", A[i][j], " ");
}<< endl;
}<< " Our string f is:
" << endl;(int i = 0; i<n; i++)
{[0] = 0.17;[1] = 1;[2] = 0.21;[3] =
2.71;(" %.0f", f[i], " ");
}<< endl;(int i = 0; i < n;
i++)
{(int j = i; j < n; j++)
{s = 0;(int k = 0; k < i; k++)+=
B[j][k] * C[k][i];[j][i] = A[j][i] - s;= 0;(int k = 0; k < i; k++)+= B[i][k]
* C[k][j];[i][j] = (A[i][j] - s) / B[i][i];
}
}<< " Our matrix B is:
" << endl;(int i = 0; i<n; i++)
{(int j = 0; j<i + 1; j++)
{(" %.4f", B[i][j], "
");
}<< endl;
}<< " Our matrix C is:
" << endl;(int i = 0; i<n; i++)
{(int j = i; j<n; j++)
{(" %.4f", C[i][j], "
");
}<< endl;
}(int i = 0; i < n; i++)
{s = 0;(int k = 0; k < i; k++)+=
B[i][k] * y[k];[i] = (f[i] - s) / B[i][i];
}(int i = n - 1; i >= 0; i--)
{s = 0;(int k = i + 1; k < n;
k++)+= C[i][k] * x[k];[i] = y[i] - s;
}<< "Vector x"
<< endl;(int i = 0; i<n; i++)
{<< x[i] << "
";
}<< endl;(int i = 0; i<n;
i++)
{s = 0;(int j = 0; j<n; j++)
{+= A[i][j] * x[j];
}[i] = s;[i] = Ax[i] - f[i];
}<< "Nevazka"
<< endl;(int i = 0; i<n; i++)
{("%1.18f\n", r[i]);
}= 0;(int i = 0; i<n; i++)
{(max< fabs(r[i]))
{= fabs(r[i]);
}
}("\n ||Ax-f||=%1.18f\n",
max);det = 1;(int i = 0; i<n; i++)
{*= B[i][i];
}<< "Determinant:"
<< endl;
cout << det << endl;0;
}
Распечатка результатов
Our matrix A is:
.1100 -0.1700 0.7200 -0.3400
.8100 0.1200 -0.9100 0.1700
.1700 -0.1800 1.0000 0.2800
.1300 0.1700 -0.9900 0.3500string f
is:
.1700 1.0000 0.2100 2.7100matrix B
is:
.1100
.8100 1.3718
.1700 0.0827 0.2619
.1300 0.3709 -0.1614 0.4259matrix C
is:
.0000 -1.5455 6.5455 -3.0909
.0000 -4.5282 1.9490
.0000 2.4600
.0000x
.0073 -79.3203 -14.8955 5.99673
.000000000000000527
.000000000000001110
.000000000000002470
.000000000000000444
||Ax-f||=0.000000000000002470
Determinant:
.0168305
Метод Гаусса
Пусть ,
матрица,
невырожденная.
Рассмотрим систему
= -
известный n-мерный вектор
=;
=
-
неизвестный
Метод Гаусса решения систем линейных уравнений с
выбором главного или ведущего элемента матрицы.
Рассмотрим 1 шаг:
.
Если то
меняем местами и строки:
то :
.
Если то
меняем местами и столбцы:
то :
.
Делим 1-ю строку полученной матрицы на
элемент :
Исключаем из
всех уравнений, кроме 1-го, т. е.:
,
В результате получим матрицу
.
Пусть проделано k-1 шагов:
.
Рассмотрим k-й шаг:
.1. .
.2. Если то
меняем местами и строки:
о .
.3. Если то
меняем местами и столбцы:
то ;
.
.4. Делим k-ю строку полученной матрицы на
элемент :
.5. Исключаем из
всех уравнений, кроме k-го, т. е.
В результате получим матрицу
.
После n-го шага получаем матрицу
Решение находим следующим образом:
Метод Гаусса с выбором главного элемента в
строке матрицы.
Рассмотрим k-й шаг,
.1.
.2. См. предыдущий метод..3. См. предыдущий
метод..4. См. предыдущий метод..5. См. предыдущий метод.
Решение находим следующим образом:
Метод Гаусса с выбором главного элемента в
столбце матрицы.
Рассмотрим k-й шаг,
.1.
k.2. См. предыдущий метод..3. См. предыдущий
метод..4. См. предыдущий метод..5. См. предыдущий метод.
Решение находим следующим образом:
Нахождение обратной матрицы
Нахождение матрицы предложенными
модификациями метода Гаусса повторет модификации метода Гаусса для решения
СЛАУ, в которых n+1 меняется на 2n.
При этом в результате проделанных n шагов
получаем матрицу
В первой и третьей модификациях:
Для второй модификации:
Вычисление определителя
Метода Гаусса с выбором ведущего элемента в
матрице.
, p = 1, s = 1 -
знак определителя на текущем шаге
-й шаг
Если
Если ,
меняем местами 1-ю и строки.
Если меняем
и
1-й столбцы.
Выносим элемент за
знак определителя
Зануляем все элементы первого столбца за
исключением первого элемента.
Пусть проделан (k-1) шаг:
где .
Если той
шаг
.1.
Если .2.Если
,
меняем местами k-ю и строки.
.3. Если меняем
и
k-й столбцы.
Выносим элемент за
знак определителя
Зануляем все элементы k-го столбца начиная с
(k+1)-го элемента.
й шаг:
.
Метод Гаусса с выбором главного или ведущего
элемента матрицы в строке
Рассмотрим k-й шаг:
k.1.
Если
k.2. См. предыдущий метод..3. См. предыдущий
метод..4. См. предыдущий метод..5. См. предыдущий метод.
Метод Гаусса с выбором главного или ведущего
элемента матрицы в столбце
Рассмотрим k-й шаг:
k.1.
Если
.2. См. предыдущий метод..3. См. предыдущий
метод..4. См. предыдущий метод..5. См. предыдущий метод.
Листинг программы
#include "stdafx.h"
#include <iomanip>
#include <iostream>
#include <math.h>namespace
std;int n = 4;Print(double array[n][n])
{(int i = 0; i < n; i++)
{(int j = 0; j < n; j++)
{("
%.4f",array[i][j]," ");
}<< endl;
}
}buldMatrA(double A[n][n])
{(int i = 0; i < n; i++)
{(int j = 0; j < n; j++)
{
A[0][0] =
0.11;[0][1] = -0.17;[0][2] = 0.72;[0][3] = -0.34;[1][0] = 0.81;[1][1] =
0.12;[1][2] = -0.91;[1][3] = 0.17;[2][0] = 0.17;[2][1] = -0.18;[2][2] =
1;[2][3] = 0.28;[3][0] = 0.13;[3][1] = 0.17;[3][2] = -0.99;[3][3] = 0.35;
}
}
}Gauss_Matr(double A[n][n], double
f[n])
{P[n];(int i = 0; i < n; i++)[i]
= i;max=-1;line = 0, column= 0;d, x[n], r[n], Ax[n];
double A_1[n][n+1];// создаём расширенную
матрицу
for (int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_1[i][j] = A[i][j];
}_1[i][n] = f[i];
}<< endl;<< "This
is a matrix A_1[n][n+1] " << endl;(int i = 0; i < n; i++)
{(int j = 0; j < n+1; j++)
{(" %.4f",
A_1[i][j]," ");
}<< endl;
}(int k = 0; k < n; k++)
{= fabs(A_1[k][k]);= k;= k;(int i =
k; i < n; i++)
{(int j = k; j < n; j++)
{(fabs(A_1[i][j]) > max)
{= fabs(A_1[i][j]);
line = i;// нахождение макс элемента и его
позиции= j;
}
}
}(line != k)// меняем строки местами
{(int j = k; j < n+1; j++)
{(A_1[k][j], A_1[line][j]);
}
}(column != k)// меняем столбцы местами
{(int i = 0; i < n; i++)
{(A_1[i][k], A_1[i][column]);
}(P[k], P[column]);
}=
A_1[k][k];(int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{_1[k][j] = (double) A_1[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_1[i][k];(int j = k; j < n+1;
j++)
{_1[i][j] -= d*A_1[k][j];
}
}
}
}<< endl;(int i = 0; i < n;
i++)
{[P[i]] = A_1[i][n];
}<<"Root"<<endl;(int
i = 0; i < n; i++)
{(" %.4f", x[i], "
");<< endl;
}(A);<<endl;(int i=0; i<n;
i++)
{s=0;(int j=0; j<n; j++)
{+=A[i][j]*x[j];
}[i]=s;[i] = Ax[i]-f[i];
}<<"Nevazka"<<endl;(int
i=0; i<n; i++)
{("%1.17f\n", r[i]);
}=0;(int i=0; i<n; i++)
{(max< fabs(r[i]))
{=fabs(r[i]);
}
}("\n ||Ax-f||=%1.18f\n",
max);
}Gauss_column(double A[n][n], double
f[n])
{max;line
= 0, column = 0;// позиции максимального элемента
double d, x[n], r[n], Ax[n];
double
A_1[n][n+1];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_1[i][j] = A[i][j];
}_1[i][n] = f[i];
}<< endl;(int k = 0; k < n;
k++)
{= fabs(A_1[k][k]);= k;= k;(int i =
k; i < n; i++)
{(fabs(A_1[i][k]) > max)
{= fabs(A_1[i][k]);
line
= i;// нахождение макс элемента и его позиции
}
}(line
!= k)// меняем строки местами
{(int j = k; j < n+1; j++)
{(A_1[k][j], A_1[line][j]);
}
}=
A_1[k][k];(int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{_1[k][j] = (double) A_1[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_1[i][k];(int j = k; j < n+1;
j++)
{_1[i][j] -= d*A_1[k][j];
}
}
}
}<<
endl;<<"Root"<<endl;(int i = 0; i < n; i++)
{[i] = A_1[i][n];(" %.4f",
x[i], " ");<< endl;
}(A);<<endl;(int i=0; i<n;
i++)
{s=0;(int j=0; j<n; j++)
{+=A[i][j]*x[j];
}[i]=s;[i] = Ax[i]-f[i];
}<<"Nevazka"<<endl;(int
i=0; i<n; i++)
{("%1.18f\n", r[i]);
}=0;(int i=0; i<n; i++)
{(max< fabs(r[i]))
{=fabs(r[i]);
}
}("\n ||Ax-f||=%1.18f\n",
max);
}Gauss_Line(double A[n][n], double
f[n])
{P[n];(int i = 0; i < n; i++)[i]
= i;max;
int
line = 0, column= 0;// позиции максимального элемента
double d, x[n], r[n], Ax[n];
double
A_1[n][n+1];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_1[i][j] = A[i][j];
}_1[i][n] = f[i];
}<< endl;(int k = 0; k < n;
k++)
{= fabs(A_1[k][k]);= k;= k;(int j =
k; j < n; j++)
{(fabs(A_1[k][j]) > max)
{= fabs(A_1[k][j]);= j;
}
}(column!= k)// меняем столбцы местами
{(int i = 0; i < n; i++)
{(A_1[i][k], A_1[i][column]);
}(P[k], P[column]);
}=
A_1[k][k];(int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{_1[k][j] = (double) A_1[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_1[i][k];(int j = k; j < n+1;
j++)
{_1[i][j] -= d*A_1[k][j];
}
}
}
}<< endl;(int i = 0; i < n;
i++)
{[P[i]] = A_1[i][n];
}<<"Root"<<endl;(int
i = 0; i < n; i++)
{(" %.4f", x[i], "
");<< endl;
}(A);<<endl;(int i=0; i<n;
i++)
{s=0;(int j=0; j<n; j++)
{+=A[i][j]*x[j];
}[i]=s;[i] = Ax[i]-f[i];
}<<"Nevazka"<<endl;(int
i=0; i<n; i++)
{("%1.18f\n", r[i]);
}=0;(int i=0; i<n; i++)
{(max< fabs(r[i]))
{=fabs(r[i]);
}
}("\n ||Ax-f||=%1.18f\n",
max);
}Determinant(double A[n][n])
{max, p = 1;s = 1;
double d;(int k = 0; k < n; k++)
{= fabs(A[k][k]);= k;= k;(int i = k;
i < n; i++)
{(int j = k; j < n; j++)
{(fabs(A[i][j]) > max)
{= fabs(A[i][j]);
line
= i;// нахождение макс элемента и фикс позиции= j;
}
}
}(line
!= k)// меняем строки местами
{(int j = k; j < n; j++)
{(A[k][j], A[line][j]);
}*= -1;
}(column != k)// меняем столбцы местами
{(int i = k; i < n; i++)
{(A[i][k], A[i][column]);
}*=
-1;
}=
A[k][k];(int j = k; j < n; j++)// деление к-й строки на макс элемент
{[k][j] = (double) A[k][j] / d;
}= p*d;(int i = k+1; i < n; i++)
{= A[i][k];(int j = k; j < n;
j++)
{[i][j] -= d*A[k][j];
}
}
}<<s*p;<< endl;
}Multipluying(double A[n][n], double
B[n][n])
{C[n][n];s = 0;(int i = 0; i < n;
i++)
{(int j = 0; j < n; j++)
{= 0;(int k = 0; k < n; k++)
{= s + A[i][k]*B[k][j];
}[i][j] = s;
}
}(C);
}Inverted_Gauss_Matr(double A[n][n])
{d;P[n];line,column;max;(int l = 0;
l < n; l++)
P[l]
= l;A_2[n][2*n];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_2[i][j] = A[i][j];
}
}(int i = 0; i < n; i++)
{(int j = n; j < 2*n; j++)
{((i+n) == j)
{_2[i][j] = 1;
}
{_2[i][j] = 0;
}
}
}(int i = 0; i < n; i++)
{(int j = 0; j < 2*n; j++)
{(" %.4f", A_2[i][j],
" " );
}<< endl;
}(int k = 0; k < n; k++)
{= fabs(A_2[k][k]);= k;= k;(int i =
k; i < n; i++)
{(int j = k; j < n; j++)
{(fabs(A_2[i][j]) > max)
{= fabs(A_2[i][j]);
line
= i;// нахождение макс элемента и фикс позиции= j;
}
}
}(line
!= k)// меняем строки местами
{(int j = k; j < 2*n; j++)
{(A_2[k][j], A_2[line][j]);
}
}(column
!= k)// меняем столбцы местами
{(int i = 0; i < n; i++)
{(A_2[i][k], A_2[i][column]);
}(P[k], P[column]);//менял тут!!!11
}=
A_2[k][k];(int j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{_2[k][j] = (double) A_2[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_2[i][k];(int j = k; j < 2*n;
j++)
{_2[i][j] -= d*A_2[k][j];
}
}
}
}A_Inverted[n][n];<< endl
<< endl;<< "Inverted matrix is:" << endl;(int i =
0; i < n; i++)
{(int j = 0; j < n; j++)
{_Inverted[P[i]][j] = A_2[i][j+n];
}
}<< endl;(A_Inverted);<<
endl << "Check" << endl << endl;(A, A_Inverted);
}Inverted_Gauss_Line(double A[n][n])
{max;line
= 0, column = 0;// позиции максимального элемента
double d;P[n];(int l = 0; l < n;
l++)
P[l]
= l;A_2[n][2*n];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_2[i][j] = A[i][j];
}
}(int i = 0; i < n; i++)
{(int j = n; j < 2*n; j++)
{((i+n) == j)
{_2[i][j] = 1;
}
{_2[i][j] = 0;
}
}
}(int k = 0; k < n; k++)
{= fabs(A_2[k][k]);= k;= k;(int j =
k; j < n; j++)
{(fabs(A_2[k][j]) > max)
{= fabs(A_2[k][j]);= j;
}
}(column != k)// меняем столбцы местами
{(int i = 0; i < n; i++)
{(A_2[i][k], A_2[i][column]);
}(P[k], P[column]);
}=A_2[k][k];(int
j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{_2[k][j] = (double) A_2[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_2[i][k];(int j = k; j < 2*n;
j++)
{_2[i][j] -= d*A_2[k][j];
}
}
}
}<<
endl;A_Inverted[n][n];<< endl;<< "Inverted matrix is:"
<< endl;(int i = 0; i < n; i++)
{(int j = 0; j < n; j++)
{_Inverted[P[i]][j] = A_2[i][j+n];
}
}<< endl;(A_Inverted);<<
endl << "Check" << endl << endl;(A, A_Inverted);
}Inverted_Gauss_Column(double
A[n][n])
{max;line
= 0, column = 0;// позиции максимального элемента
double d;A_2[n][2*n];// создаём расширенную матрицуP[n];(int
l = 0; l < n; l++)[l] = l;(int i = 0; i < n; i ++)
{(int j = 0; j < n; j++)
{_2[i][j] = A[i][j];
}
}(int i = 0; i < n; i++)
{(int j = n; j < 2*n; j++)
{((i+n) == j)
{_2[i][j] = 1;
}
{_2[i][j] = 0;
}
}
}(int k = 0; k < n; k++)
{= fabs(A_2[k][k]);= k;= k;(int i =
k; i < n; i++)
{(fabs(A_2[i][k]) > max)
{= fabs(A_2[i][k]);
line
= i;// нахождение макс элемента и фикс позиции
}
}(line
!= k)// меняем строки местами
{(int j = k; j < 2*n; j++)
{(A_2[k][j], A_2[line][j]);
}
}=
A_2[k][k];(int j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{_2[k][j] = (double) A_2[k][j] / d;
}(int i = 0; i < n; i++)
{(i != k)
{= A_2[i][k];(int j = k; j < 2*n;
j++)
{_2[i][j] -= d*A_2[k][j];
}
}
}
}A_Inverted[n][n];<<
endl;<< "Inverted matrix is:" << endl;(int i = 0; i <
n; i++)
{(int j = 0; j < n; j++)
{_Inverted[i][j] = A_2[i][j+n];
}
}<< endl;(A_Inverted);<<
endl << "Check" << endl << endl;(A, A_Inverted);
}main()
{A[n][n];(A);<< "Our
matrix A is:" << endl;
Print(A);f[n]
= {0.17,1,0.21,2.71}; // это вектор свободных членов
cout << endl <<
"Our vector f is:" << endl;(int i = 0; i < n; i++)
{(" %.4f", f[i], "
");
}<<endl;<< "Gauss
method - max element in MATRIX";_Matr(A, f);<< "Gauss method -
max element in COLUMN";_column(A, f);<< "Gauss method - max
element in LINE";_Line(A, f);<< "Determinant:" <<
endl;(A);(A);<< "matrix A_2[n][2*n]" <<
endl;_Gauss_Matr(A);<< "Matrix by lines" <<
endl;_Gauss_Line(A);<< "Matrix by the column" <<
endl;_Gauss_Column(A);("PAUSE");}
Распечатка
результатовmatrix A is:
0.1100 -0.1700 0.7200 -0.3400
.8100 0.1200 -0.9100 0.1700
.1700 -0.1800 1.0000 0.2800
.1300 0.1700 -0.9900 0.3500vector f
is:
.1700 1.0000 0.2100 2.7100method -
max element in MATRIXis a matrix A_1[n][n+1]
.1100 -0.1700 0.7200 -0.3400 0.1700
.8100 0.1200 -0.9100 0.1700 1.0000
.1700 -0.1800 1.0000 0.2800 0.2100
.1300 0.1700 -0.9900 0.3500 2.7100
.0073
.3203
.8955
.9967
.00000000000000008
.00000000000000089
.00000000000000086
.00000000000000178
||Ax-f||=0.000000000000001776method
- max element in COLUMN
.0073
.3203
.8955
.9967
.000000000000003469
.000000000000000888
.000000000000000916
.000000000000000000
||Ax-f||=0.000000000000003469method
- max element in LINE
.0073
.3203
.8955
.9967
.000000000000001249
.000000000000002442
.000000000000000472
.000000000000000888
||Ax-f||=0.000000000000002442:
.0168305A_2[n][2*n]
.1100 -0.1700 0.7200 -0.3400 1.0000
0.0000 0.0000 0.0000
.8100 0.1200 -0.9100 0.1700 0.0000
1.0000 0.0000 0.0000
.1700 -0.1800 1.0000 0.2800 0.0000
0.0000 1.0000 0.0000
.1300 0.1700 -0.9900 0.3500 0.0000
0.0000 0.0000 1.0000matrix is:
.4253 1.7694 0.2315 -2.4292
.4211 9.1371 -1.6455 -30.7307
.9593 1.5461 0.2594 -5.7760
.3063 -0.7221 1.4468 2.3479
.0000 -0.0000 0.0000 -0.0000
.0000 1.0000 0.0000 0.0000
.0000 0.0000 1.0000 -0.0000
.0000 0.0000 0.0000 1.0000by
linesmatrix is:
.4253 1.7694 0.2315 -2.4292
.4211 9.1371 -1.6455 -30.7307
.9593 1.5461 0.2594 -5.7760
.3063 -0.7221 1.4468 2.3479
.0000 -0.0000 0.0000 0.0000
.0000 1.0000 -0.0000 -0.0000
.0000 0.0000 1.0000 -0.0000
.0000 0.0000 -0.0000 1.0000by the
columnmatrix is:
-1.4253
1.7694 0.2315 -2.4292
.4211
9.1371 -1.6455 -30.7307
.9593
1.5461 0.2594 -5.7760
.3063
-0.7221 1.4468 2.3479
.0000
-0.0000 -0.0000 0.0000
.0000
1.0000 0.0000 0.0000
.0000
0.0000 1.0000 -0.0000
.0000
-0.0000 0.0000 1.0000
линейный алгебраический уравнение гаусс
Вывод
В нашем случае более точным оказался метод
Гаусса с выбором ведущего элемента в матрице, его невязка составила
||Ax-f||=0.000000000000001776.
Потом идет метод Гаусса с выбором ведущего
элемента в строке
||Ax-f||=0.000000000000002442.
А уже после идут метод факторизации с невязкой
||Ax-f||=0.000000000000002470
и метод Гаусса с выбором ведущего элемента в
столбце с невязкой
||Ax-f||=0.000000000000003469
соответственно. Так же было найдено решение
системы
Root
.0073
.3203
.8955
.9967
и определитель
Determinant:
.0168305
значение которых совпало для всех методов.