Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
201 |
строки к последнему, а нечётные – от последнего к 0-му. Текст программы приведён на
листинге
#include <iostream> using namespace std;
int main(int argc, char **argv)
{
int **a,n=6,k=0,i,j;
//Выделяем память для хранения матрицы a=new int *[n];
for(i=0;i<n;i++) a[i]=new int [n];
//Перебираем все строки матрицы. for(i=0;i<n;i++)
if (i%2==0) |
//Строки с чётными номерами |
|
//Заполняем возрастающей |
|
//последовательностью чисел |
|
//слева направо |
for(j=0;j<n;j++) |
|
a[i][j]=++k; |
|
else |
//Строки с нечётными номерами |
|
//Заполняем возрастающей |
//последовательностью чисел //справа налево
for(j=n-1;j>=0;j--) a[i][j]=++k;
cout<<"Вывод матрицы A"<<endl; for(i=0;i<n; cout<<endl,i++)
for(j=0;j<n;cout<<a[i][j]<<"\t",j++); return 0;
}
6.4Решение некоторых задач линейной алгебры
Вэтом параграфе рассмотрим использование матриц при решении таких задач линейной алгебры, как сложение, вычитание и умножение матриц, решение систем линейных алгебраических уравнений вычисление определителя и обратной матрицы. В процессе решения подобных задач будут написаны универсальные функции, которые можно использовать при решении матричной алгебры.
ЗАДАЧА 6.9. Заданы четыре матрицы вещественных чисел A(N,M), |
|
B(N,M), С(M,N), D(M,N). Вычислить матрицу |
C=(( A+ B)(C−D))2 . |
Суммой (разностью) матриц одинаковой размерности A и B называется матрица |
|
C, элементы которой получаются сложением |
Ci , j =Ai , j+ Bi , j (вычитанием |
Ci , j =Ai , j−Bi , j ) соответствующих элементов исходных матриц.
Напоминаем читателю алгоритм умножения матриц на примере двух матриц
(a0,0 a0,1 a1,0 a1,1 a2,0 a2,1
a0,2)(b0,0
a1,2 b1,0
a2,2 b2,0
b0,1) b1,1 .
b2,1
Воспользовавшись правилом «строка на столбец», получим матрицу:
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
202 |
(c0,0 c0,1) (a0,0 b0,0+a0,1 b1,0+a0,2 b2,0 c1,0 c1,1 = a1,0 b0,0+a1,1 b1,2+a1,2 b2,1 c2,0 c2,1 a2,0 b0,0+a2,1 b1,0+a2,2 b2,0
a0,0 b0,1+a0,1 b1,1+a0,2 b2,1)
a1,0 b0,1+a1,1 b1,1+a1,2 b2,1 . a2,0 b0,1+a2,1 b1,1+a2,2 b2,1
Произведением матриц A(N,M) и B(M,L) является матрица C(N, L), каждый элемент которой Ci , j вычисляется по формуле:
M −1
Ci , j= ∑ Ai ,k Bk , j , где i = 0,N-1 и j = 0,L-1.
k=0
Операция умножения имеет смысл только в том случае, если количество строк левой матрицы совпадает с количеством столбцов правой. Кроме того, A B≠B A .
При решении задачи будем использовать динамические матрицы и двойные указатели, напишем следующие функции
•float **sum_m(float **A, float **B, int N, int M) – функция формирует матрицу, которая является суммой двух матриц. Здесь A, B – указатели на исходные матрицы, N, M – количество строк и столбцов матриц,
функция возвращает указатель на сформированную матрицу, которая является суммой двух матриц A и B.
•float **minus_m(float **A, float **B, int N, int M) –
функция формирует матрицу, которая является разностью двух матриц. Здесь A, B – указатели на исходные матрицы, N, M – количество строк и столбцов матриц,
функция возвращает указатель на сформированную матрицу, которая является разностью двух матриц A и B.
•float **product_m(float **A,float **B,int N,int M,int L) –
функция формирует матрицу, которая является произведением двух матриц. Здесь A, B – указатели на исходные матрицы. Матрица A имеет N строк и M столбцов, матрица B имеет M строка и L столбцов, функция возвращает
указатель на сформированную матрицу, которая является произведением двух матриц A и B.
•float **create_m(int N, int M) – функция создаёт матрицу, в которой будет N строк и M столбцов, осуществляет ввод элементов матрицы, функция возвращает указатель на сформированную матрицу.
•void output_m(float **A, int N, int M) – функция построчного вывода на экран матрицы A, которая имеет N строк и M столбцов.
В главной функции необходимо будет только вызывать написанные функции:
#include <iostream> using namespace std;
//функция вычисления суммы двух матриц.
float **sum_m(float **A, float **B, int N, int M)
{
int i,j; float **temp;
temp=new float *[N]; for(i=0;i<N;i++)
temp[i]=new float [M];
for(i=0;i<N;i++)
for(j=0;j<M;j++)
temp[i][j]=A[i][j]+B[i][j];
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
203 |
return temp; |
//Возвращаем матрицу как |
|
//двойной указатель |
}
//функция вычисления разности двух матриц.
float **minus_m(float **A, float **B, int N, int M) {int i,j;
float **temp;
temp=new float *[N]; for(i=0;i<N;i++)
temp[i]=new float [M];
for(i=0;i<N;i++)
for(j=0;j<M;j++) temp[i][j]=A[i][j]-B[i][j];
return temp; //Возвращаем матрицу как //двойной указатель
}
//Функция вычисления произведения двух матриц.
float **product_m(float **A,float **B,int N,int M,int L)
{ |
|
int i,j,k; |
//указатель для хранения |
float **temp; |
|
temp=new float *[N]; |
//результирующей матрицы |
//выделение памяти для |
|
for(i=0;i<N;i++) |
//хранения результирующей |
temp[i]=new float [L]; |
//матрицы |
//Вычисляем произведение матриц //Последовательно формируем все элементы матрицы for(i=0;i<N;i++)
for(j=0;j<L;j++)
//Элемент с индексами i,j - скалярное произведение //i-й строки матрицы A и j-го столбца матрицы B
for(temp[i][j]=k=0;k<M;k++)
temp[i][j]+=A[i][k]*B[k][j]; //Возвращаем матрицу как двойной указатель return temp;
}
//Функция создаёт динамическую матрицу вещественных чисел //размерности N на M, в этой же функции
//осуществляется и ввод элементов матрицы float **create_m(int N, int M)
{
int i,j; float **temp;
temp=new float *[N]; for(i=0;i<N;i++)
temp[i]=new float [M]; cout<<"Ввод матрицы\n"; for(i=0;i<N;i++)
for(j=0;j<M;j++)
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
204 |
cin>>temp[i][j]; return temp;
}
//Функция осуществляет построчный вывод матрицы A(N,M) void output_m(float **A, int N, int M)
{
int i,j;
//Цикл по строкам. По окончанию вывода //всех элементов строки - переход на новую строку. for(i=0;i<N;cout<<endl,i++)
for(j=0;j<M;j++)//Цикл по столбцам
cout<<A[i][j]<<"\t"; |
//Вывод элемента матрицы |
} |
//и символа табуляции. |
|
int main(int argc, char **argv)
{
//указатели для хранения исходных и //результирующие матрицы
float **A, **B, **C, **D,**result; int N,M;
//Ввод размерностей матрицы cout<<"N=";cin>>N; cout<<"M=";cin>>M;
//Выделение памяти и ввод матриц A, B, C, D, //обращаясь к функции create_m.
A=create_m(N,M);
B=create_m(N,M);
C=create_m(M,N);
D=create_m(M,N);
//Вычисление результирующей матрицы. result=product_m(product_m(sum_m(A,B,N,M),
minus_m(C,D,M,N),N,M,N), product_m(sum_m(A,B,N,M),
minus_m(C,D,M,N),N,M,N),N,N,N); //Вывод результирующей матрицы.
output_m(result,N,N); return 0;
}
Далее приведена программа решения задачи 6.9 с помощью динамических матриц и обычных указателей41 без комментариев. Рекомендуем самостоятельно разобраться с
этой версией программы.
#include <iostream> using namespace std;
float *sum_m(float *A, float *B, int N, int M)
{
int i,j; float *temp;
temp=new float [N*M];
41Обращаем внимание читателя, что при использовании одинарных указателей обращение к элементам матрицы происходит быстрее. При обработке матриц большой размерности (более 1000000 элементов) имеет смысл использовать именно одинарные указатели для хранения и обработки матриц. Это позволит ускорить работу программ на 10-15%.
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
205 |
for(i=0;i<N;i++)
for(j=0;j<M;j++)
temp[i*M+j]=A[i*M+j]+B[i*M+j]; return temp;
}
float *minus_m(float *A, float *B, int N, int M)
{int i,j; float *temp;
temp=new float [N*M];
for(i=0;i<N;i++)
for(j=0;j<M;j++) temp[i*M+j]=A[i*M+j]-B[i*M+j];
return temp;
}
float *product_m(float *A, float *B, int N, int M, int L)
{int i,j,k; float *temp;
temp=new float [N*L]; for(i=0;i<N;i++)
for(j=0;j<L;j++)
for(temp[i*L+j]=k=0;k<M;k++)
temp[i*L+j]+=A[i*M+k]*B[k*L+j];
return temp;
}
float *create_m(int N, int M)
{int i,j; float *temp;
temp=new float [N*M]; cout<<"Ввод матрицы\n"; for(i=0;i<N;i++)
for(j=0;j<M;j++)
cin>>temp[i*M+j]; return temp;
}
void output_m(float *A, int N, int M)
{int i,j; for(i=0;i<N;cout<<endl,i++)
for(j=0;j<M;j++)
cout<<A[i*M+j]<<"\t";
}
int main(int argc, char **argv)
{float *A, *B, *C, *D,*result; int N,M;
cout<<"N=";cin>>N;
cout<<"M=";cin>>M; A=create_m(N,M); B=create_m(N,M); C=create_m(M,N); D=create_m(M,N);
result=product_m(product_m(sum_m(A,B,N,M), minus_m(C,D,M,N),N,M,N),
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
206 |
product_m(sum_m(A,B,N,M), minus_m(C,D,M,N),N,M,N),N,N,N);
output_m(result,N,N); return 0;
}
ЗАДАЧА 6.10. Решить систему линейных алгебраических уравнений.
При решении этой задачи напишем универсальную функцию решения системы линейных алгебраических уравнений метод Гаусса, а в функции main() просто
вызовем эту функцию. Вспомним метод Гаусса.
Пусть дана система линейных алгебраических уравнений (СЛАУ) с n неизвестными
{a0 0 x0+a01 x1+...+a0n−1 xn−1=b0 ,
a10 x0+a1 1 x1+...+a1n−1 xn−1=b1 , (6.1)
...
an−10 x0+an−11 x1+...+an−1 n−1 xn−1=bn−1
|
|
|
a0 0 |
a01 |
... a0n−1 |
|
|
|
|
Обозначим через |
A= |
|
a10 |
a11 |
... |
a1n−1 |
матрицу коэффициентов |
||
|
|
|
... |
... |
... |
... |
|
|
|
|
|
(an−1 0 |
an−11 |
... |
an−1 n−1) |
|
(xn−1) |
|
|
(bn−1) |
|
|
|
|
|
|
|||
|
b0 |
|
|
|
|
|
|
x0 |
|
системы (6.1), через b= |
b1 |
|
– столбец ее свободных членов, и через |
x= x1 |
– |
||||
|
... |
|
|
|
|
|
|
... |
|
столбец из неизвестных (искомый вектор). Тогда система (6.1) может быть записана в виде матричного уравнения Ax=b .
Наиболее распространенным приемом решения систем линейных уравнений является алгоритм последовательного исключения неизвестных – метод Гаусса.
При решении систем линейных алгебраических уравнений этим методом всевозможные преобразования производят не над уравнениями системы (6.1), а над так называемой расширенной матрицей системы, которая получается путем добавления к основной матрице А столбца свободных членов b.
Первый этап решения системы уравнений, называемый прямым ходом метода Гаусса, заключается в приведении расширенной матрицы (6.2) к треугольному виду. Это означает, что все элементы матрицы (6.2) ниже главной диагонали должны быть равны нулю.
|
a00 |
a01 |
... |
a0 n−1 |
b0 |
|
A '= |
a10 |
a11 |
... |
a1 n−1 |
b1 |
(6.2) |
|
... |
... |
... |
... |
... |
|
|
(an−10 |
an−11 ... an−1n−1 bn−1) |
|
|||
На первом |
этапе |
необходимо обнулить |
элементы 0-го столбца расширенной |
|||
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
207 |
|||||||
матрицы |
|
|
|
|
|
|
|
|
|
|
a00 |
a01 |
a02 ... |
a0n |
−1 |
b0 |
|
|
|
0 |
a11 |
a12 ... |
a1n |
−1 |
b1 |
|
A'= 0 |
0 |
a22 ... |
a2n |
−1 |
b2 |
(6.3) |
||
|
( |
0 |
0 |
0 ... |
a3n |
−1 |
b3 |
|
|
... ... ... ... |
... |
... |
|
||||
|
0 |
0 |
0 ... |
an−1n−1 |
bn−1) |
|
||
Для этого необходимо из каждой строки (начиная со первой) вычесть нулевую, умноженную на некоторое число М. В общем виде этот процесс можно записать так:
1-я строка = 1-я строка – М × 0-я строка 2-я строка = 2-я строка – М × 0-я строка
…
i-я строка = i-я строка – М × 0-я строка
…
n-1-я строка = n-1-я строка – М × 0-я строка
Понятно, что преобразование элементов первой строки будет происходить по формулам:
a10=a10 – M a00 |
a11=a11 – M a01 … |
a1i=a1i – M a0i … |
||||
a1n−1=a1 n−1 – M a0 n−1 |
b1=b1 |
– M b0 |
|
|
|
|
Так как целью данных преобразований является обнуление первого элемента |
||||||
строки, то М выбирам из условия: |
a10=a10 – M a00=0 |
. Следовательно, |
M = |
a10 |
. |
|
|
||||||
|
|
|
|
|
a00 |
|
Элементы второй строки и коэффициент М можно рассчитать аналогично:
a20=a20 – M a00 |
a21=a21 – M a01 … a1i=a1i – M a0i … |
|
a20 |
|
||||||
a2n−1=a2n−1 – M a0 n−1 |
b2=b2 – M b0 |
a20=a20 – M a00=0 |
|
M = |
|
|||||
. |
a00 . |
|||||||||
|
|
|
|
|
|
|
||||
Таким образом, преобразование элементов i–й строки будет происходить |
||||||||||
следующим образом: |
|
|
|
|
|
|
||||
ai0=ai0 – M a00 |
ai1=ai1 – M a01 … aii=aii – M a0i … |
|
|
|
|
|||||
ain−1=ain−1 – M a0 n−1 |
bi=bi – M b0 . |
|
|
|
|
|
||||
Коэффициент М для i–й строки выбирается из условия ai0=ai0 – M a00=0 и |
||||||||||
равен M = |
ai0 |
. |
|
|
|
|
|
|
||
a |
00 |
|
|
|
|
|
|
|||
|
|
|
|
|
|
|
|
|
||
После проведения подобных преобразований для всех строк матрица (6.2) примет
вид
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
209 |
Рисунок 6.12 Блок-схема алгоритма преобразования расширенной матрицы к треугольному
виду
Заметим, что если в матрице (6.2) на главной диагонали встретится элемент
ak , k , равный нулю, то расчет коэффициента |
M = |
aik |
для к-й строки будет |
|
akk |
||||
|
|
|
невозможен. Избежать деления на ноль можно, избавившись от нулевых элементов на главной диагонали. Для этого перед обнулением элементов в k–м столбце необходимо
найти в нем максимальный по модулю элемент (среди расположенных ниже ak , k ,
запомнить номер строки, в которой он находится, и поменять ее местами с k-й. Алгоритм, отображающий эти преобразования, приведен на рис. 6.13.
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
210 |
Рисунок 6.13: Блок-схема алгоритма перестановки строк
расширенной матрицы
Врезультате выполнения прямого хода метода Гаусса матрица (6.2) преобразуется
вматрицу (6.3), а система уравнений (6.1) будет иметь следующий вид:
a0 0 x0+a01 x1+a2 0 x2+...+a0n−1 x n−1=b0 |
, |
|
|
|
|
|
|||||||||
{ |
a11 x1+a21 x2+...+a1 n−1 xn−1=b1 |
, |
|
|
|
|
|
||||||||
|
|
a22 x 2+...+a2n−1 xn−1=b2 |
, |
|
|
|
(6.4) |
||||||||
|
|
|
|
|
|
|
... |
|
|
|
|
|
|||
|
|
|
an−1 n−1 xn−1=bn−1 |
|
|
|
|
|
|||||||
Решение системы (7.4) называют обратным ходом метода Гаусса. |
|
|
|
|
|||||||||||
Последнее (n-1)-е уравнение системы (7.4) имеет вид: an−1 n−1 xn−1=bn−1 . |
|
||||||||||||||
Тогда, если |
a |
n−1 n−1 |
≠0 , то x |
n−1 |
= |
|
bn−1 |
. В случае, если |
a |
n−1 n−1 |
=0, |
и |
|||
a |
n−1n−1 |
||||||||||||||
|
|
|
|
|
|
|
|
|
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|||
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
212 |
невыполнения условия.
Рисунок 6.15: Блок-схема алгоритма решения СЛАУ методом Гаусса
Теперь алгоритм решения СЛАУ, представленный на рис. 6.15 разобьем на главную функцию main() и функцию решения СЛАУ методом Гаусса. В функции main() будет находиться ввод исходных данных, обращение к функции SLAU решения системы линейных алгебраических уравнений и вывод вектора решения. Функция SLAU предназначена для решения системы линейных алгебраических уравнений методом Гаусса.
При написании функции следует учитывать следующее: в методе Гаусса изменяются матрица коэффициентов и вектор правых частей. Поэтому, для того чтобы
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
213 |
их не испортить, в функции SLAU матрицу коэффициентов и вектор правых частей необходимо скопировать во внутренние переменные, и в функции обрабатывать внутренние переменные-копии.
Функция SLAU возвращает значение 0, если решение найдено, -1 – если система имеет бесконечное множество решений, -2 – если система не имеет решений.
Далеек приведено решение задачи 6.10 с подробными комментариями.
#include <iostream> #include <math.h> using namespace std;
int SLAU(double **matrica_a, int n, double *massiv_b, double *x)
//Функция SLAU возвращает значение типа int:
//0, если решение найдено, -1 – если система имеет
//бесконечное множество
//решений, -2 – если система не имеет решений.
//Формальные параметры функции: n – размерность системы,
//matrica_a – матрица коэффициентов СЛАУ, massiv_b –
//вектор правых частей, x – решение СЛАУ,
//a, b,x передаются как указатели.
{
int i,j,k,r; double c,M,max,s;
//Матрица a – копия матрицы коэффициентов,
//массив b – копия вектора правых частей. double **a, *b;
//Выделение памяти для a и b. a=new double *[n]; for(i=0;i<n;i++)
a[i]=new double[n]; b=new double [n];
//В a записываем копию матрицы коэффициентов, в b копию
//вектора правых частей.
for(i=0;i<n;i++)
for(j=0;j<n;j++) a[i][j]=matrica_a[i][j];
for(i=0;i<n;i++) b[i]=massiv_b[i];
// Прямой ход метода Гаусса: приводим матрицу a
//(копию матрицы коэффициентов СЛАУ) к диагональному виду. for(k=0;k<n;k++)
{
//Поиск максимального по модулю элемента в k-м столбце. max=fabs(a[k][k]);
r=k;
for(i=k+1;i<n;i++)
if (fabs(a[i][k])>max)
{
max=fabs(a[i][k]);
r=i;
}
//Меняем местами k-ю и r-ю (строку, где находится
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
215 |
a=new double *[N]; for(i=0;i<N;i++) a[i]=new double[N]; b=new double [N]; x=new double [N];
//Ввод матрицы правых частей и вектора свободных членов. cout<<"Input Matrix A"<<endl;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
cin>>a[i][j];
cout<<"Input massiv B"<<endl; for(i=0;i<N;i++)
cin>>b[i];
//Вызов функции решения СЛАУ методом Гаусса. По значению
//переменной result можно судить, сколько корней имеет
//система. Если result=0, то система имеет единственное
//решение, result= -1, то система имеет бесконечное //множество решений, result=-2, система не имеет решений. result=SLAU(a,N,b,x);
if (result==0)
{
//Вывод массива решения.
cout<<"Massiv X"<<endl; for(i=0;i<N;i++)
cout<<x[i]<<"\t";
cout<<endl;
}
else if (result==-1)
cout<<"Бесконечное множество решений\n"; else if (result==-2)
cout<<"Нет решений\n";
}
ЗАДАЧА 6.11. Найти обратную матрицу к квадратной матрицы A(N,N).
Один из методов вычисления обратной матрицы основан на решении систем линейных алгебраических уравнений. Пусть задана некоторая матрица A:
a0 0 |
|
a0 1 |
|
a0 2 ... |
a0 n−1 |
|
A= a10 |
|
a11 |
|
a12 ... |
a1 n−1 |
(6.5) |
... |
|
... |
|
... ... |
... |
|
(an−1 |
0 |
an−1 |
1 |
an−1 2 ... |
an−1n−1) |
|
Необходимо найти матрицу A–1, которая является обратной к матрице А:
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
216 |
||||||||
|
y00 |
|
y01 |
y0 2 ... |
y0n−1 |
|
|
|
|
Y =A−1= y10 |
|
y11 |
y12 ... |
y1n−1 |
|
|
(6.6) |
||
|
... |
|
... |
... |
... |
... |
|
|
|
|
(yn−10 |
|
yn−11 yn−1 2 ... |
yn−1n−1) |
|
|
|||
Матрица (6.6) |
будет |
обратной |
к |
матрице (6.5), |
если выполняется соотношение |
||||
A A−1=E , где Е – это единичная матрица, или более подробно: |
|
||||||||
(an−1 0 |
an−11 |
... an−1 n−1)(yn−1 0 |
y n−11 |
... yn−1n−1) |
|
||||
a0 0 |
a01 |
... |
a0 n−1 |
|
y0 0 |
y0 1 |
... |
y0n−1 |
|
a10 |
a11 |
... |
a1 n−1 |
|
y10 |
y1 1 |
... |
y1n−1 = E |
(6.7) |
... |
... |
... |
... |
|
... |
... |
... |
... |
|
Результат перемножения матриц из соотношения (6.7) можно представить поэлементно в виде n систем линейных уравнений. Умножение матрицы (6.5) на нулевой столбец матрицы (6.6) даст нулевой столбец единичной матрицы:
a0 0 y00+a0 1 y10+...+a0 n−1 yn−10=1 , |
|
|
a1 0 y0 0+a11 y1 0+...+a1n−1 yn−10=0 , |
|
|
... |
. |
|
ai 0 y0 0+ai 1 y1 0+...+ai n−1 yn−10=0 , |
||
|
||
... |
|
|
{an−10 y00+an−11 y1 0+...+an−1n−1 yn−10=0 |
|
При умножении матрицы A втрой столбец обратной матрицы получается следующая система линейных алгебраический уравнений.
{a0 0 y01+a01 y11+...+a0n−1 yn−1 1=0 , a1 0 y0 1+a1 1 y11+...+a1n−1 yn−1 1=1 ,
...
ai 0 y0 1+ai 1 y11+...+ain−1 yn−11=0 ,
...
an−10 y01+an−11 y11+...+an−1 n−1 yn−11=0
Система, полученная в результате умножения матрицы (6.5) на i-й столбец матрицы (6.6), будет выглядеть следующим образом:
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
217 |
a0 0 y0i +a01 y1i+...+a0n−1 yn−1i =0 , |
|
|
a1 0 y0 i+a11 y1i +...+a1n−1 yn−1i =0 , |
|
|
... |
|
|
ai 0 y0 i+ai 1 y1i +...+ai n−1 yn−1i=1, |
|
|
... |
|
|
{an−10 y0i +an−11 y1i +...+an−1 n−1 yn−1i=0 |
|
|
Понятно, что n-я система будет иметь вид: |
|
|
a0 0 y0n−1+a0 1 y1 n−1+...+a0n−1 yn−1 n−1=0 , |
|
|
a1 0 y0 n−1+a11 y1n−1+...+a1n−1 yn−1 n−1=0 , |
|
|
... |
. |
|
ai 0 y0 n−1+ai 1 y1 n−1+...+ai n−1 yn−1 n−1=0, |
||
|
||
... |
|
|
{an−10 y0 n−1+an−11 y1 n−1+...+an−1 n−1 yn−1n−1=1 |
|
Решением каждой из приведенных выше систем будет i-й столбец обратной матрицы. Количество систем равно размерности обратной матрицы. Для отыскания решений систем линейных алгебраических уравнений можно воспользоваться методом Гаусса.
Описанный алгоритм представлен в виде блок-схемы на рис. 6.16. Блоки 2–5 отражают формирование столбца единичной матрицы. Если условие 3 выполняется и элемент находится на главной диагонали, то он равен единице, все остальные элементы нулевые. В блоке 6 происходит вызов подпрограммы для решения системы уравнений методом Гаусса. В качестве параметров в эту подпрограмму передается исходная матрица А, сформированный в пунктах 2–5 вектор свободных коэффициентов В, размерность системы n. Вектор X будет решением i-й системы уравнений и, следовательно, i-м столбцом искомой матрицы Y.
Алексеев Е.Р., Чеснокова О.В. Самоучитель по программированию на C/C++. |
221 |
cout<<"Input Matrix A"<<endl; for(i=0;i<N;i++)
for(j=0;j<N;cin>>a[i][j],j++);
//Вычисление обратной матрицы. result=INVERSE(a,N,b);
//Если обратная матрица существует, то вывести ее на
//экран.
if (result==0)
{
cout<<"Inverse matrix"<<endl; for(i=0;i<N;cout<<endl,i++)
for(j=0;j<N;cout<<b[i][j]<<"\t",j++);
}
else
//Если обратная матрица не существует, то вывести
//соответствующее сообщение.
cout<<"No Inverse matrix"<<endl;
}
ЗАДАЧА 6.12. Найти определитель квадратной матрицы A(N,N).
Пусть задана матрица (6.2), необходимо вычислить ее определитель. Для этого матрицу необходимо преобразовать к треугольному виду (6.3), а затем воспользоваться свойством, известным из курса линейной алгебры, которое гласит, что определитель
n−1
треугольной матрицы равен произведению ее диагональных элементов: det A = ∏ a ii .
i =0
Преобразование матрицы (6.2) к виду (6.3) можно осуществить с помощью прямого хода метода Гаусса. Алгоритм вычисления определителя матрицы, изображенный в виде блок-схемы на рис. 6.17, представляет собой алгоритм прямого хода метода Гаусса, в процессе выполнения которого проводится перестановка строк матрицы. Эта операция приводит к смене знака определителя. В блок-схеме момент смены знака отражен в блоках 8–9. В блоке 8 определяется, будут ли строки меняться местами, и если ответ утвердительный, то в блоке 9 происходит смена знака определителя. В блоках 15–16 выполняется непосредственное вычисление определителя путем перемножения диагональных элементов преобразованной матрицы.
