Прямые методы решения систем линейных алгебраических уравнений
Изучение основ линейных алгебраических уравнений. Нахождение решения систем данных уравнений методом Гаусса с выбором ведущего элемента в строке, в столбце и в матрице. Выведение исходной матрицы. Основные правила применения метода факторизации.
| Рубрика | Математика |
| Вид | лабораторная работа |
| Язык | русский |
| Дата добавления | 28.10.2014 |
| Размер файла | 489,3 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на http://www.allbest.ru/
Министерство образования и науки, молодежи и спорта Украины
Харьковский национальный университет имени В.Н. Каразина
Лабораторная работа №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.18f\n", 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.18f\n", 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.17f\n", 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.18f\n", 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.18f\n", 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.18f\n", 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.18f\n", 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.18f\n", 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
значение которых совпало для всех методов.
Размещено на Allbest.ru
Подобные документы
Понятие и специфические черты системы линейных алгебраических уравнений. Механизм и этапы решения системы линейных алгебраических уравнений. Сущность метода исключения Гаусса, примеры решения СЛАУ данным методом. Преимущества и недостатки метода Гаусса.
контрольная работа [397,2 K], добавлен 13.12.2010Характеристика и использование итерационных методов для решения систем алгебраических уравнений, способы формирования уравнений. Методы последовательных приближений, Гаусса-Зейделя, обращения и триангуляции матрицы, Халецкого, квадратного корня.
реферат [60,6 K], добавлен 15.08.2009Основные правила решения системы заданных уравнений методом Гаусса с минимизацией невязки и методом простых итераций. Понятие исходной матрицы; нахождение определителя для матрицы коэффициентов. Пример составления блок-схемы метода минимизации невязок.
лабораторная работа [264,1 K], добавлен 24.09.2014Характеристика способов решения систем линейных алгебраических уравнений (СЛАУ). Описание проведения вычислений на компьютере методом Гаусса, методом квадратного корня, LU–методом. Реализация метода вращений средствами системы программирования Delphi.
курсовая работа [118,4 K], добавлен 04.05.2014Рассмотрение систем линейных алгебраических уравнений общего вида. Сущность теорем и их доказательство. Особенность трапецеидальной матрицы. Решение однородных и неоднородных линейных алгебраических уравнений, их отличия и применение метода Гаусса.
реферат [66,4 K], добавлен 14.08.2009Методы решения систем линейных алгебраических уравнений (СЛАУ): Гаусса и Холецкого, их применение к конкретной задаче. Код программы решения перечисленных методов на языке программирования Borland C++ Builder 6. Понятие точного метода решения СЛАУ.
реферат [58,5 K], добавлен 24.11.2009Сущность итерационного метода решения задачи, оценка его главных преимуществ и недостатков. Разновидности итерационных методов решения систем линейных алгебраических уравнений: Якоби, Хорецкого и верхней релаксации, их отличия и возможности применения.
курсовая работа [39,2 K], добавлен 01.12.2009Основные действия над матрицами, операция их умножения. Элементарные преобразования матрицы, матричный метод решения систем линейных уравнений. Элементарные преобразования систем, методы решения произвольных систем линейных уравнений, свойства матриц.
реферат [111,8 K], добавлен 09.06.2011Структура и элементы, принципы формирования и правила разрешения систем линейных алгебраических уравнений. История развития различных методов решения: матричного, Крамера, с помощью функции Find. Особенности применения возможностей программы Mathcad.
контрольная работа [96,0 K], добавлен 09.03.2016Сущность и содержание метода Крамера как способа решения квадратных систем линейных алгебраических уравнений с ненулевым определителем основной матрицы. Содержание основных правил Крамера, сферы и особенности их практического применения в математике.
презентация [987,7 K], добавлен 22.11.2014
