Прямые методы решения систем линейных алгебраических уравнений

Министерство образования и науки, молодежи и спорта Украины

Харьковский национальный университет имени В.Н. Каразина

Лабораторная работа №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;

int line = 0, column= 0;// позиции максимального элемента

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

значение которых совпало для всех методов.