Прямые методы решения систем линейных алгебраических уравнений
Работа из раздела: «
Математика»
/
Министерство образования и науки, молодежи и спорта Украины
Харьковский национальный университет имени В.Н. Каразина
Лабораторная работа №2
Прямые методы решения систем линейных алгебраических уравнений
Выполнила:
студентка группы МП-31
Кальницкая Б.М.
Проверил:
доц. Скорик В.А.
Харьков 2014
Постановка задачи
I. Найти решение систем линейных алгебраических уравнений Ах=b, найти А-1, вычислить det A.
1. Методом Гаусса с выбором ведущего элемента в строке.
2. Методом Гаусса с выбором ведущего элемента в столбце.
3. Методом Гаусса с выбором ведущего элемента в матрице. На печать вывести исходную матрицу A, вектор b, решение x, невязку, det A, А-1. Сравнить полученые результаты.
II. Найти решение систем линейных алгебраических уравнений Ах=b, вычислить det A.
1. Методом факторизации.
Напечать вывести исходную матрицу A, вектор b, решение x, невязку, вычислить det A. Сравнить полученые результаты.
Вариант №4
А = , b =
Метод Факторизации
Теорема.
Пусть
Тогда А представима единственным образом в виде где
- нижнетреугольная,
- верхнетреугольная;
.
При этом решение сводится к решению двух систем
Листинг программы
#include 'stdafx.h'
#include <stdio.h>
#include <iostream>
#include <math.h>
using namespace std;
const int n = 4;
int main()
{
int i = 0, j = 0, k = 0, m = 0;
double A[n][n], B[n][n], C[n][n], f[n], x[n], y[n], r[n], Ax[n], max = -1;
cout << ' Our matrix A is: ' << endl;
for (i = 0; i<n; i++)
{
for (j = 0; j<n; j++)
{
A[0][0] = 0.11;
A[0][1] = -0.17;
A[0][2] = 0.72;
A[0][3] = -0.34;
A[1][0] = 0.81;
A[1][1] = 0.12;
A[1][2] = -0.91;
A[1][3] = 0.17;
A[2][0] = 0.17;
A[2][1] = -0.18;
A[2][2] = 1;
A[2][3] = 0.28;
A[3][0] = 0.13;
A[3][1] = 0.17;
A[3][2] = -0.99;
A[3][3] = 0.35;
B[i][j] = 0;
C[i][j] = 0;
x[i] = 0;
y[i] = 0;
printf(' %.4f', A[i][j], ' ');
}
cout << endl;
}
cout << ' Our string f is: ' << endl;
for (int i = 0; i<n; i++)
{
f[0] = 0.17;
f[1] = 1;
f[2] = 0.21;
f[3] = 2.71;
printf(' %.0f', f[i], ' ');
}
cout << endl;
for (int i = 0; i < n; i++)
{
for (int j = i; j < n; j++)
{
double s = 0;
for (int k = 0; k < i; k++)
s += B[j][k] * C[k][i];
B[j][i] = A[j][i] - s;
s = 0;
for (int k = 0; k < i; k++)
s += B[i][k] * C[k][j];
C[i][j] = (A[i][j] - s) / B[i][i];
}
}
cout << ' Our matrix B is: ' << endl;
for (int i = 0; i<n; i++)
{
for (int j = 0; j<i + 1; j++)
{
printf(' %.4f', B[i][j], ' ');
}
cout << endl;
}
cout << ' Our matrix C is: ' << endl;
for (int i = 0; i<n; i++)
{
for (int j = i; j<n; j++)
{
printf(' %.4f', C[i][j], ' ');
}
cout << endl;
}
for (int i = 0; i < n; i++)
{
double s = 0;
for (int k = 0; k < i; k++)
s += B[i][k] * y[k];
y[i] = (f[i] - s) / B[i][i];
}
for (int i = n - 1; i >= 0; i--)
{
double s = 0;
for (int k = i + 1; k < n; k++)
s += C[i][k] * x[k];
x[i] = y[i] - s;
}
cout << 'Vector x' << endl;
for (int i = 0; i<n; i++)
{
cout << x[i] << ' ';
}
cout << endl;
for (int i = 0; i<n; i++)
{
double s = 0;
for (int j = 0; j<n; j++)
{
s += A[i][j] * x[j];
}
Ax[i] = s;
r[i] = Ax[i] - f[i];
}
cout << 'Nevazka' << endl;
for (int i = 0; i<n; i++)
{
printf('%1.18fn', r[i]);
}
max = 0;
for (int i = 0; i<n; i++)
{
if (max< fabs(r[i]))
{
max = fabs(r[i]);
}
}
printf('n ||Ax-f||=%1.18fn', max);
double det = 1;
for (int i = 0; i<n; i++)
{
det *= B[i][i];
}
cout << 'Determinant:' << endl;
cout << det << endl;
return 0;
}
Распечатка результатов
Our matrix A is:
0.1100 -0.1700 0.7200 -0.3400
0.8100 0.1200 -0.9100 0.1700
0.1700 -0.1800 1.0000 0.2800
0.1300 0.1700 -0.9900 0.3500
Our string f is:
0.1700 1.0000 0.2100 2.7100
Our matrix B is:
0.1100
0.8100 1.3718
0.1700 0.0827 0.2619
0.1300 0.3709 -0.1614 0.4259
Our matrix C is:
1.0000 -1.5455 6.5455 -3.0909
1.0000 -4.5282 1.9490
1.0000 2.4600
1.0000
Vector x
-5.0073 -79.3203 -14.8955 5.99673
Nevazka
-0.000000000000000527
0.000000000000001110
-0.000000000000002470
0.000000000000000444
||Ax-f||=0.000000000000002470
Determinant:
0.0168305
Метод Гаусса
Пусть , матрица, невырожденная.
Рассмотрим систему
= - известный n-мерный вектор
=; = - неизвестный
Метод Гаусса решения систем линейных уравнений с выбором главного или ведущего элемента матрицы.
Рассмотрим 1 шаг:
.
Если то меняем местами и строки:
то : .
Если то меняем местами и столбцы:
то : .
Делим 1-ю строку полученной матрицы на элемент :
Исключаем из всех уравнений, кроме 1-го, т. е.:
,
В результате получим матрицу
.
Пусть проделано k-1 шагов:
.
Рассмотрим k-й шаг:
k.1. .
k.2. Если то меняем местами и строки:
о .
k.3. Если то меняем местами и столбцы:
то ; .
k.4. Делим k-ю строку полученной матрицы на элемент :
k.5. Исключаем из всех уравнений, кроме k-го, т. е.
В результате получим матрицу
.
После n-го шага получаем матрицу
Решение находим следующим образом:
Метод Гаусса с выбором главного элемента в строке матрицы.
Рассмотрим k-й шаг,
k.1.
k.2. См. предыдущий метод.
k.3. См. предыдущий метод.
k.4. См. предыдущий метод.
k.5. См. предыдущий метод.
Решение находим следующим образом:
Метод Гаусса с выбором главного элемента в столбце матрицы.
Рассмотрим k-й шаг,
k.1.
k.2. См. предыдущий метод.
k.3. См. предыдущий метод.
k.4. См. предыдущий метод.
k.5. См. предыдущий метод.
Решение находим следующим образом:
Нахождение обратной матрицы
Нахождение матрицы предложенными модификациями метода Гаусса повторет модификации метода Гаусса для решения СЛАУ, в которых n+1 меняется на 2n.
При этом в результате проделанных n шагов получаем матрицу
В первой и третьей модификациях:
Для второй модификации:
Вычисление определителя
Метода Гаусса с выбором ведущего элемента в матрице.
, p = 1, s = 1 - знак определителя на текущем шаге
1-й шаг
Если
Если , меняем местами 1-ю и строки.
Если меняем и 1-й столбцы.
Выносим элемент за знак определителя
Зануляем все элементы первого столбца за исключением первого элемента.
Пусть проделан (k-1) шаг:
где .
Если то
k-й шаг
k.1.
Если
k.2.Если , меняем местами k-ю и строки.
k.3. Если меняем и k-й столбцы.
Выносим элемент за знак определителя
Зануляем все элементы k-го столбца начиная с (k+1)-го элемента.
n-й шаг:
.
Метод Гаусса с выбором главного или ведущего элемента матрицы в строке
Рассмотрим k-й шаг:
k.1.
Если
k.2. См. предыдущий метод.
k.3. См. предыдущий метод.
k.4. См. предыдущий метод.
k.5. См. предыдущий метод.
Метод Гаусса с выбором главного или ведущего элемента матрицы в столбце
Рассмотрим k-й шаг:
k.1.
Если
k.2. См. предыдущий метод.
k.3. См. предыдущий метод.
k.4. См. предыдущий метод.
k.5. См. предыдущий метод.
Листинг программы
#include 'stdafx.h'
#include <iomanip>
#include <iostream>
#include <math.h>
using namespace std;
const int n = 4;
void Print(double array[n][n])
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
printf(' %.4f',array[i][j],' ');
}
cout << endl;
}
}
void buldMatrA(double A[n][n])
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
A[0][0] = 0.11;
A[0][1] = -0.17;
A[0][2] = 0.72;
A[0][3] = -0.34;
A[1][0] = 0.81;
A[1][1] = 0.12;
A[1][2] = -0.91;
A[1][3] = 0.17;
A[2][0] = 0.17;
A[2][1] = -0.18;
A[2][2] = 1;
A[2][3] = 0.28;
A[3][0] = 0.13;
A[3][1] = 0.17;
A[3][2] = -0.99;
A[3][3] = 0.35;
}
}
}
void Gauss_Matr(double A[n][n], double f[n])
{
int P[n];
for (int i = 0; i < n; i++)
P[i] = i;
double max=-1;
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 ++)
{
for (int j = 0; j < n; j++)
{
A_1[i][j] = A[i][j];
}
A_1[i][n] = f[i];
}
cout << endl;
cout << 'This is a matrix A_1[n][n+1] ' << endl;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n+1; j++)
{
printf(' %.4f', A_1[i][j],' ');
}
cout << endl;
}
for (int k = 0; k < n; k++)
{
max = fabs(A_1[k][k]);
line = k;
column = k;
for (int i = k; i < n; i++)
{
for (int j = k; j < n; j++)
{
if (fabs(A_1[i][j]) > max)
{
max = fabs(A_1[i][j]);
line = i;// нахождение макс элемента и его позиции
column = j;
}
}
}
if (line != k)// меняем строки местами
{
for (int j = k; j < n+1; j++)
{
swap(A_1[k][j], A_1[line][j]);
}
}
if (column != k)// меняем столбцы местами
{
for (int i = 0; i < n; i++)
{
swap(A_1[i][k], A_1[i][column]);
}
swap(P[k], P[column]);
}
d = A_1[k][k];
for (int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{
A_1[k][j] = (double) A_1[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_1[i][k];
for (int j = k; j < n+1; j++)
{
A_1[i][j] -= d*A_1[k][j];
}
}
}
}
cout << endl;
for (int i = 0; i < n; i++)
{
x[P[i]] = A_1[i][n];
}
cout<<'Root'<<endl;
for (int i = 0; i < n; i++)
{
printf(' %.4f', x[i], ' ');
cout << endl;
}
buldMatrA(A);
cout<<endl;
for(int i=0; i<n; i++)
{
double s=0;
for(int j=0; j<n; j++)
{
s+=A[i][j]*x[j];
}
Ax[i]=s;
r[i] = Ax[i]-f[i];
}
cout<<'Nevazka'<<endl;
for(int i=0; i<n; i++)
{
printf('%1.17fn', r[i]);
}
max=0;
for(int i=0; i<n; i++)
{
if(max< fabs(r[i]))
{
max=fabs(r[i]);
}
}
printf('n ||Ax-f||=%1.18fn', max);
}
void Gauss_column(double A[n][n], double f[n])
{
double 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 ++)
{
for (int j = 0; j < n; j++)
{
A_1[i][j] = A[i][j];
}
A_1[i][n] = f[i];
}
cout << endl;
for (int k = 0; k < n; k++)
{
max = fabs(A_1[k][k]);
line = k;
column = k;
for (int i = k; i < n; i++)
{
if (fabs(A_1[i][k]) > max)
{
max = fabs(A_1[i][k]);
line = i;// нахождение макс элемента и его позиции
}
}
if (line != k)// меняем строки местами
{
for (int j = k; j < n+1; j++)
{
swap(A_1[k][j], A_1[line][j]);
}
}
d = A_1[k][k];
for (int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{
A_1[k][j] = (double) A_1[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_1[i][k];
for (int j = k; j < n+1; j++)
{
A_1[i][j] -= d*A_1[k][j];
}
}
}
}
cout << endl;
cout<<'Root'<<endl;
for (int i = 0; i < n; i++)
{
x[i] = A_1[i][n];
printf(' %.4f', x[i], ' ');
cout << endl;
}
buldMatrA(A);
cout<<endl;
for(int i=0; i<n; i++)
{
double s=0;
for(int j=0; j<n; j++)
{
s+=A[i][j]*x[j];
}
Ax[i]=s;
r[i] = Ax[i]-f[i];
}
cout<<'Nevazka'<<endl;
for(int i=0; i<n; i++)
{
printf('%1.18fn', r[i]);
}
max=0;
for(int i=0; i<n; i++)
{
if(max< fabs(r[i]))
{
max=fabs(r[i]);
}
}
printf('n ||Ax-f||=%1.18fn', max);
}
void Gauss_Line(double A[n][n], double f[n])
{
int P[n];
for (int i = 0; i < n; i++)
P[i] = i;
double 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 ++)
{
for (int j = 0; j < n; j++)
{
A_1[i][j] = A[i][j];
}
A_1[i][n] = f[i];
}
cout << endl;
for (int k = 0; k < n; k++)
{
max = fabs(A_1[k][k]);
line = k;
column = k;
for (int j = k; j < n; j++)
{
if (fabs(A_1[k][j]) > max)
{
max = fabs(A_1[k][j]);
column = j;
}
}
if (column!= k)// меняем столбцы местами
{
for (int i = 0; i < n; i++)
{
swap(A_1[i][k], A_1[i][column]);
}
swap(P[k], P[column]);
}
d = A_1[k][k];
for (int j = k; j < n+1; j++)// деление к-й строки на макс элемент
{
A_1[k][j] = (double) A_1[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_1[i][k];
for (int j = k; j < n+1; j++)
{
A_1[i][j] -= d*A_1[k][j];
}
}
}
}
cout << endl;
for (int i = 0; i < n; i++)
{
x[P[i]] = A_1[i][n];
}
cout<<'Root'<<endl;
for (int i = 0; i < n; i++)
{
printf(' %.4f', x[i], ' ');
cout << endl;
}
buldMatrA(A);
cout<<endl;
for(int i=0; i<n; i++)
{
double s=0;
for(int j=0; j<n; j++)
{
s+=A[i][j]*x[j];
}
Ax[i]=s;
r[i] = Ax[i]-f[i];
}
cout<<'Nevazka'<<endl;
for(int i=0; i<n; i++)
{
printf('%1.18fn', r[i]);
}
max=0;
for(int i=0; i<n; i++)
{
if(max< fabs(r[i]))
{
max=fabs(r[i]);
}
}
printf('n ||Ax-f||=%1.18fn', max);
}
void Determinant(double A[n][n])
{
double max, p = 1;
int s = 1;
int line = 0, column= 0;// позиции максимального элемента
double d;
for (int k = 0; k < n; k++)
{
max = fabs(A[k][k]);
line = k;
column = k;
for (int i = k; i < n; i++)
{
for (int j = k; j < n; j++)
{
if (fabs(A[i][j]) > max)
{
max = fabs(A[i][j]);
line = i;// нахождение макс элемента и фикс позиции
column = j;
}
}
}
if (line != k)// меняем строки местами
{
for (int j = k; j < n; j++)
{
swap(A[k][j], A[line][j]);
}
s *= -1;
}
if (column != k)// меняем столбцы местами
{
for (int i = k; i < n; i++)
{
swap(A[i][k], A[i][column]);
}
s *= -1;
}
d = A[k][k];
for (int j = k; j < n; j++)// деление к-й строки на макс элемент
{
A[k][j] = (double) A[k][j] / d;
}
p = p*d;
for (int i = k+1; i < n; i++)
{
d = A[i][k];
for (int j = k; j < n; j++)
{
A[i][j] -= d*A[k][j];
}
}
}
cout<<s*p;
cout << endl;
}
void Multipluying(double A[n][n], double B[n][n])
{
double C[n][n];
double s = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
s = 0;
for (int k = 0; k < n; k++)
{
s = s + A[i][k]*B[k][j];
}
C[i][j] = s;
}
}
Print(C);
}
void Inverted_Gauss_Matr(double A[n][n])
{
double d;
int P[n];
int line,column;
double max;
for (int l = 0; l < n; l++)
P[l] = l;
double A_2[n][2*n];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{
for (int j = 0; j < n; j++)
{
A_2[i][j] = A[i][j];
}
}
for (int i = 0; i < n; i++)
{
for (int j = n; j < 2*n; j++)
{
if ((i+n) == j)
{
A_2[i][j] = 1;
}
else
{
A_2[i][j] = 0;
}
}
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < 2*n; j++)
{
printf(' %.4f', A_2[i][j], ' ' );
}
cout << endl;
}
for (int k = 0; k < n; k++)
{
max = fabs(A_2[k][k]);
line = k;
column = k;
for (int i = k; i < n; i++)
{
for (int j = k; j < n; j++)
{
if (fabs(A_2[i][j]) > max)
{
max = fabs(A_2[i][j]);
line = i;// нахождение макс элемента и фикс позиции
column= j;
}
}
}
if (line != k)// меняем строки местами
{
for (int j = k; j < 2*n; j++)
{
swap(A_2[k][j], A_2[line][j]);
}
}
if (column != k)// меняем столбцы местами
{
for (int i = 0; i < n; i++)
{
swap(A_2[i][k], A_2[i][column]);
}
swap(P[k], P[column]);//менял тут!!!11
}
d = A_2[k][k];
for (int j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{
A_2[k][j] = (double) A_2[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_2[i][k];
for (int j = k; j < 2*n; j++)
{
A_2[i][j] -= d*A_2[k][j];
}
}
}
}
double A_Inverted[n][n];
cout << endl << endl;
cout << 'Inverted matrix is:' << endl;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
A_Inverted[P[i]][j] = A_2[i][j+n];
}
}
cout << endl;
Print(A_Inverted);
cout << endl << 'Check' << endl << endl;
Multipluying(A, A_Inverted);
}
void Inverted_Gauss_Line(double A[n][n])
{
double max;
int line = 0, column = 0;// позиции максимального элемента
double d;
int P[n];
for (int l = 0; l < n; l++)
P[l] = l;
double A_2[n][2*n];// создаём расширенную матрицу
for (int i = 0; i < n; i ++)
{
for (int j = 0; j < n; j++)
{
A_2[i][j] = A[i][j];
}
}
for (int i = 0; i < n; i++)
{
for (int j = n; j < 2*n; j++)
{
if ((i+n) == j)
{
A_2[i][j] = 1;
}
else
{
A_2[i][j] = 0;
}
}
}
for (int k = 0; k < n; k++)
{
max = fabs(A_2[k][k]);
line = k;
column= k;
for (int j = k; j < n; j++)
{
if (fabs(A_2[k][j]) > max)
{
max = fabs(A_2[k][j]);
column= j;
}
}
if (column != k)// меняем столбцы местами
{
for (int i = 0; i < n; i++)
{
swap(A_2[i][k], A_2[i][column]);
}
swap(P[k], P[column]);
}
d =A_2[k][k];
for (int j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{
A_2[k][j] = (double) A_2[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_2[i][k];
for (int j = k; j < 2*n; j++)
{
A_2[i][j] -= d*A_2[k][j];
}
}
}
}
cout << endl;
double A_Inverted[n][n];
cout << endl;
cout << 'Inverted matrix is:' << endl;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
A_Inverted[P[i]][j] = A_2[i][j+n];
}
}
cout << endl;
Print(A_Inverted);
cout << endl << 'Check' << endl << endl;
Multipluying(A, A_Inverted);
}
void Inverted_Gauss_Column(double A[n][n])
{
double max;
int line = 0, column = 0;// позиции максимального элемента
double d;
double A_2[n][2*n];// создаём расширенную матрицу
int P[n];
for (int l = 0; l < n; l++)
P[l] = l;
for (int i = 0; i < n; i ++)
{
for (int j = 0; j < n; j++)
{
A_2[i][j] = A[i][j];
}
}
for (int i = 0; i < n; i++)
{
for (int j = n; j < 2*n; j++)
{
if ((i+n) == j)
{
A_2[i][j] = 1;
}
else
{
A_2[i][j] = 0;
}
}
}
for (int k = 0; k < n; k++)
{
max = fabs(A_2[k][k]);
line = k;
column = k;
for (int i = k; i < n; i++)
{
if (fabs(A_2[i][k]) > max)
{
max = fabs(A_2[i][k]);
line = i;// нахождение макс элемента и фикс позиции
}
}
if (line != k)// меняем строки местами
{
for (int j = k; j < 2*n; j++)
{
swap(A_2[k][j], A_2[line][j]);
}
}
d = A_2[k][k];
for (int j = k; j < 2*n; j++)// деление к-й строки на макс элемент
{
A_2[k][j] = (double) A_2[k][j] / d;
}
for (int i = 0; i < n; i++)
{
if (i != k)
{
d = A_2[i][k];
for (int j = k; j < 2*n; j++)
{
A_2[i][j] -= d*A_2[k][j];
}
}
}
}
double A_Inverted[n][n];
cout << endl;
cout << 'Inverted matrix is:' << endl;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
A_Inverted[i][j] = A_2[i][j+n];
}
}
cout << endl;
Print(A_Inverted);
cout << endl << 'Check' << endl << endl;
Multipluying(A, A_Inverted);
}
void main()
{
double A[n][n];
buldMatrA(A);
cout << 'Our matrix A is:' << endl;
Print(A);
double f[n] = {0.17,1,0.21,2.71}; // это вектор свободных членов
cout << endl << 'Our vector f is:' << endl;
for (int i = 0; i < n; i++)
{
printf(' %.4f', f[i], ' ');
}
cout<<endl;
cout << 'Gauss method - max element in MATRIX';
Gauss_Matr(A, f);
cout << 'Gauss method - max element in COLUMN';
Gauss_column(A, f);
cout << 'Gauss method - max element in LINE';
Gauss_Line(A, f);
cout << 'Determinant:' << endl;
Determinant(A);
buldMatrA(A);
cout << 'matrix A_2[n][2*n]' << endl;
Inverted_Gauss_Matr(A);
cout << 'Matrix by lines' << endl;
Inverted_Gauss_Line(A);
cout << 'Matrix by the column' << endl;
Inverted_Gauss_Column(A);
system('PAUSE');}
Распечатка результатов
Our matrix A is:
0.1100 -0.1700 0.7200 -0.3400
0.8100 0.1200 -0.9100 0.1700
0.1700 -0.1800 1.0000 0.2800
0.1300 0.1700 -0.9900 0.3500
Our vector f is:
0.1700 1.0000 0.2100 2.7100
Gauss method - max element in MATRIX
This is a matrix A_1[n][n+1]
0.1100 -0.1700 0.7200 -0.3400 0.1700
0.8100 0.1200 -0.9100 0.1700 1.0000
0.1700 -0.1800 1.0000 0.2800 0.2100
0.1300 0.1700 -0.9900 0.3500 2.7100
Root
-5.0073
-79.3203
-14.8955
5.9967
Nevazka
-0.00000000000000008
-0.00000000000000089
0.00000000000000086
-0.00000000000000178
||Ax-f||=0.000000000000001776
Gauss method - max element in COLUMN
Root
-5.0073
-79.3203
-14.8955
5.9967
Nevazka
0.000000000000003469
-0.000000000000000888
-0.000000000000000916
0.000000000000000000
||Ax-f||=0.000000000000003469
Gauss method - max element in LINE
Root
-5.0073
-79.3203
-14.8955
5.9967
Nevazka
0.000000000000001249
-0.000000000000002442
-0.000000000000000472
-0.000000000000000888
||Ax-f||=0.000000000000002442
Determinant:
0.0168305
matrix A_2[n][2*n]
0.1100 -0.1700 0.7200 -0.3400 1.0000 0.0000 0.0000 0.0000
0.8100 0.1200 -0.9100 0.1700 0.0000 1.0000 0.0000 0.0000
0.1700 -0.1800 1.0000 0.2800 0.0000 0.0000 1.0000 0.0000
0.1300 0.1700 -0.9900 0.3500 0.0000 0.0000 0.0000 1.0000
Inverted matrix is:
-1.4253 1.7694 0.2315 -2.4292
-28.4211 9.1371 -1.6455 -30.7307
-4.9593 1.5461 0.2594 -5.7760
0.3063 -0.7221 1.4468 2.3479
Check
1.0000 -0.0000 0.0000 -0.0000
0.0000 1.0000 0.0000 0.0000
-0.0000 0.0000 1.0000 -0.0000
0.0000 0.0000 0.0000 1.0000
Matrix by lines
Inverted matrix is:
-1.4253 1.7694 0.2315 -2.4292
-28.4211 9.1371 -1.6455 -30.7307
-4.9593 1.5461 0.2594 -5.7760
0.3063 -0.7221 1.4468 2.3479
Check
1.0000 -0.0000 0.0000 0.0000
-0.0000 1.0000 -0.0000 -0.0000
0.0000 0.0000 1.0000 -0.0000
-0.0000 0.0000 -0.0000 1.0000
Matrix by the column
Inverted matrix is:
-1.4253 1.7694 0.2315 -2.4292
-28.4211 9.1371 -1.6455 -30.7307
-4.9593 1.5461 0.2594 -5.7760
0.3063 -0.7221 1.4468 2.3479
Check
1.0000 -0.0000 -0.0000 0.0000
-0.0000 1.0000 0.0000 0.0000
-0.0000 0.0000 1.0000 -0.0000
-0.0000 -0.0000 0.0000 1.0000
линейный алгебраический уравнение гаусс
Вывод
В нашем случае более точным оказался метод Гаусса с выбором ведущего элемента в матрице, его невязка составила
||Ax-f||=0.000000000000001776.
Потом идет метод Гаусса с выбором ведущего элемента в строке
||Ax-f||=0.000000000000002442.
А уже после идут метод факторизации с невязкой
||Ax-f||=0.000000000000002470
и метод Гаусса с выбором ведущего элемента в столбце с невязкой
||Ax-f||=0.000000000000003469
соответственно. Так же было найдено решение системы
Root
-5.0073
-79.3203
-14.8955
5.9967
и определитель
Determinant:
0.0168305
значение которых совпало для всех методов.
