Как сделать матрицу в си. Двумерные массивы в c
Вообще-то программировать расчёт определителей не нужно. Их умеет считать, скажем, встроенная функция МОПРЕД из Excel:
- набираем элементы матрицы в смежных ячейках, например, матрица размерностью 4*4 показана на картинке;
- в нужной ячейке вводим формулу (в нашем случае =МОПРЕД(A1:D4) и нажимаем Enter:)
Не труднее вычислить и в MathCAD - просто нажать кнопку на панели матриц...
Но иногда нужен алгоритм, а не ответ... вот немного кода на консольном C++, на совершенство он не претендует, но нули в матрице или "не тот" порядок элементов смущать функцию determinant не должны. Пример из main - 1001-й на работу с динамической матрицей средствами C++ :) Остальное закомментировано в исходнике.
#define bool int
#define true 1
#define false 0
int search (double **a, int m, int n, double what,
bool match, unsigned int &uI, unsigned int &uJ, unsigned int starti, unsigned int startj) {
// Поиск в матрице a[m][n] элемента с указанным значением what
// Возвращаеются его номер строки и столбца uI, uJ, если элемент найден.
// match - искать равный элемент или отличный от указанного.
// Вернёт 0 - не найдено, не 0 - найдено
if ((!m) || (!n)) return 0;
if ((starti >= n) || (startj >= m)) return 0;
for (unsigned int i = starti; i < n; i++)
for (unsigned int j = startj; j < m; j++) {
if (match == true) {
if (a[i][i] == what) {
uI = i; uJ = j; return 1;
}
}
else if (a[i][j] != what) {
uI = i; uJ = j; return 1;
}
}
return 0;
}
void swaprows (double **a, int n, int m, unsigned int x1, unsigned int x2) {
//Меняет в матрице a[n][m] строки с номерами x1 и x2 местами
if ((!n) || (!m)) return;
if ((x1 >= n) || (x2 >= n) || (x1 == x2)) return;
double tmp;
for (unsigned int x = 0; x < m; x++) {
tmp = a[x];
a[x] = a[x];
a[x] = tmp;
}
return;
};
void swapcolumns (double **a, int n, int m, unsigned int x1, unsigned int x2) {
//Меняет в матрице a[n][m] столбцы с номерами x1 и x2 местами
if ((!n) || (!m)) return;
if ((x1 >= m) || (x2 >= m) || (x1 == x2)) return;
double tmp;
for (unsigned int x = 0; x < n; x++) {
tmp = a[x];
a[x] = a[x];
a[x] = tmp;
}
return;
};
double determinant (double **a, unsigned int n) {
//Вычисление определителя квадратной матрицы a[n][n]
unsigned int m = n;
if (m == 0) return 0;
if (m == 1) return a;
if (m == 2) return (a * a - a * a);
bool sign = false; // смена знака определителя. по умолчанию - нет
double det = 1; // определитель
double tmp;
unsigned int x, y;
for (unsigned int i = 0; i < n; i++) { // цикл по всей главной диагонали
if (a[i][i] == 0) { // если элемент на диагонали равен 0, то ищем ненулевой элемент в матрице
if (!search(a,m,n,0, false, y, x, i, i)) return 0; // если все элементы нулевые, то опр. = 0
if (i != y) { // меняем i-ую строку с y-ой
swaprows(a,m,n,i, y);
sign = !sign;
}
if (i != x) { // меняем i-ый столбец с x-ым
swapcolumns(a,m,n,i, x);
sign = !sign;
}
// таким образом, в a[i][i], теперь ненулевой элемент.
}
// выносим элемент a[i][i] за определитель
det *= a[i][i];
tmp = a[i][i];
for (x = i; x < m; x++) {
a[i][x] = a[i][x] / tmp;
}
// таким образом a[i][i] теперь равен 1
// зануляем все элементы стоящие под (i, i)-ым,
// при помощи вычитания с опр. коеффициентом
for (y = i + 1; y < n; y++) {
tmp = a[y][i];
for (x = i; x < m; x++)
a[y][x] -= (a[i][x]*tmp);
}
}
if (sign) return det*(-1);
return det;
};
#include Безусловно, по входным данным можно восстановить матрицы, тривиальным образом их перемножить и вывести результат в заданном виде. Как пример плохого стиля программирования: наивный алгоритм приводит к почти двукратному перерасходу потребляемой памяти и существенно уступает в производительности. Существует другое решение, прийти к которому можно путем последовательного приспособления стандартных матричных операций к формату входных данных. Наибольшую сложность, как вычислительную, так и идейную, представляет умножение матриц, в данном случае — возведение в квадрат. Нижеприведенная последовательность шагов позволит перемножать симметричные матрицы, используя их линейное представление в формате исходных данных. Подпространство симметричных матриц незамкнуто относительно умножения: произведением двух симметричных матриц может быть несимметричная матрица. \left(\begin{array}{ccc} 1 & 1 & 3 \\ 1 & 4 & 5 \\ 3 & 5 & 0\end{array} \right) \cdot \left(\begin{array}{ccc} 4 & 0 & 0 \\ 0 & 4 & 3 \\ 0 & 3 & 2 \end{array} \right) = \left(\begin{array}{ccc} 4 & 13 & 9 \\ 4 & 31 & 22 \\ 12 & 20 & 15 \end{array} \right) Степень симметрической матрицы также является симметрической матрицей. Доказательство основано на представлении матрицы как представления линейного оператора и на свойствах эрмитовых операторов. Во всех дальнейших выкладках подразумевается, что матрица представлена линейным массивом из \frac{n(n+1)}{2} элементов. Для начала, заметим, что элемент c_{i,j} матрицы C=A^{2}, равен скалярному произведению (как векторов в стандартном базисе) i-ой строки матрицы A на j-ую её строку (в силу того, что в симметричной матрице j-ая строка совпадает с j-м столбцом). Следовательно, для возведения в степень симметричной матрицы необходимо и достаточно реализовать операцию скалярного перемножения двух её строк. Тогда следует понять, как по данному представлению матрицы получить её i-ую строку. Для удобства, выпишем имеющиеся элементы в виде полной матрицы. Заметим, что первым элементом i-ой строки будет i-ый элемент первой строки, и обобщим это наблюдение. Обозначим позицию текущего интересующего нас элемента i-ой строки как j. Если j < i, то следует выбрать i-ый элемент j-ой строки, иначе следует выбрать все элементы j-ой строки, лежащие правее данного. Графически можно интерпретировать алгоритм таким образом: начиная с i-го элемента первой строки, спускаться вертикально вниз по матрице до тех пор, пока не будет достигнута i-ая строка, далее — двигаться вправо до конца строки. Наглядность алгоритма позволяет легко воплотить его программно. Теперь можно перейти непосредственно к реализации.
Внимание! Об
обновлениях смотри внизу этой страницы. Последнее обновление – от 18.04.2018.
Введение
Класс
DMatrix разработан на языке C++ (в среде Borl
a
nd
Builder
6) и предназначен для
встраивания в исходный код с целью упрощения программирования операций с
матрицами.
Класс
позволяет использовать при программировании переопределенные операции:
присвоение, сложение матриц, умножение матриц, умножение матрицы на число (справа).
Например, код C++, использующий объекты данного класса, может выглядеть так:
A = B;
A = B + C;
A = B * C;
A = B * c;
где
A
,
B
и
C
– объекты класса, с
– переменная
типа float
,
double
или
long
double
.
Кроме
того, класс содержит функции обращения матрицы, вычисления определителя и
транспонирования:
A = B.
Inverse
();
-обращение матрицы
B
;
d
=
B
.
det
(
);
-вычисление определителя матрицы
B
;
A = B.
T
(
);
-транспонирование матрицы
B
.
Значения
ячеек матрицы имеют тип long
double
, что позволяет производить операции с
большой точностью. В некоторых достаточно сложных прикладных задачах,
построенных на итеративных алгоритмах, увеличение точности вычислений приводит
к ускорению сходимости алгоритма, то есть даже ускоряет работу программы.
Важное
преимущество нашего класса заключается в реализации подхода «динамическая
матрица».
В
прикладных задачах, связанных с обработкой потоков информации, встает задача
оперативного формирования матриц на основе данных (сигналов), поступающих по
нескольким каналам. При этом, во-первых, данные не должны пропадать из-за
нехватки времени, они должны без временных задержек наполнять матрицы, позволяя
математическому алгоритму быстро приступать к их обработке. Во-вторых, память
компьютера должна использоваться рационально, чтобы избежать переполнения
памяти при больших потоках информации.
Объект
класса DMatrix можно изобразить в виде стакана:
Матрица,
хранящаяся в данном объекте, имеет размерность m*n
. Как правило, в случае работы с потоком данных число n
– это количество переменных,
содержащихся в потоке, и/или каких-то рассчитанных величин, например, производных
по времени от переменных потока.
Рациональное
использование памяти при работе с динамической матрицей подразумевает
динамическое выделение памяти для строк матрицы (низ стакана) и динамическое
освобождение памяти от использованных строк (верх стакана).
При
операциях с матрицами, таких, как сложение, умножение, вычисление определителя
и др., обработке подвергаются только актуальные данные, для указания на которые
служит переменная k.
При
обработке сигналов от устройств часто возникают задача формирования и решения в
реальном времени систем уравнений. Для этой цели сделаны классы LSM и
PROJECTION, работающие с нашими динамическими матрицами. В них реализованы
алгоритмы решения систем линейных алгебраических уравнений с гибкой системой
настройки параметров. Алгоритмы базируются на методе наименьших квадратов с
«коэффициентом экспоненциального забывания» и проекционном решающем алгоритме.
Настройки этих алгоритмов позволяют адаптировать их как для чистки входящих
сигналов, так и для быстрого реагирования решения на скачки сигналов на входе.
Таким образом, программист (или эксплуатант), подбирая эти настройки, должен
найти оптимальный баланс между точностью решения и быстротой реагирования.
Переменные и функции класса
DMatrix
Класс
содержит переменные:
int
m
;
- количество строк матрицы
int
n
;
- количество столбцов матрицы
int k;
-
указатель на последнюю строку матрицы. При операциях в качестве актуальных
строк матрицы используются строки массива с индексами(k-m), … , ( k
-1).
int M;
- количество указателей на строки матрицы
long double **data;
- указатель на двумерный массив значений
ячеек матрицы
booloblom;
- признак аварийного
результата выполнения операции
Класс
содержит функции:
long
double
__
fastcall
det
(
void
);
- расчет определителя
матрицы
DMatrix
__
fastcall
T
(
void
);
-
транспонирование матрицы
DMatrix
__
fastcall
Inverse
(
void
);
- расчет обратной матрицы
void
__
fastcall
Ini
(
m
0,
n
0,
M
0,
k
0);
- инициализация переменных объекта-матрицы и выделение памяти
void
__
fastcall
de
_
allocate
(
void
);
- чистка памяти: удаление
m
строк
матрицы из диапазона (k-m), … , ( k
-1) и
указателей наэти строки
void
__
fastcall
Allocate
(
int
k
0);
- выделение памяти для
указанной строки
void
__
fastcall
Delete
(
int
k
0);
- чистка памяти:
удаление указанной строки
Работа с матрицами
Пример
1.
Рассмотрим
простейший пример – сложение двух матриц:
Сначала
нужно добавить в проект наш класс. Если используется среда Borland
Builder
, то необходимо добавить в проект файл
dmatrix
.
cpp
и подключить его в
unit
’е, в котором мы будем работать с
матрицами; для этого напишем в
header
-файле
директиву#include
"
d
matrix.h
"
.
Добавим
на форму кнопку
Button
1 и
надпись Label1. В функцию Button1Click поместим следующий код.
Объявим
3 матрицы:
DMatrixA, B, C;
(слагаемые и результат,
C
=
A
+
B
),
опишем
свойства этих матриц и выделим память для строк и столбцов матриц:
A.m = 2;
A.n = 2;
A.k = 2;
A.M = 2;
A.oblom = false;
A.data = new long double*;
for (inti = 0; i < A.k;
i++)A.data[i] = new long double;
То же
самое можно написать более компактным образом, с помощью функции Ini:
A
.
Ini
(2, 2, 2, 2);
В
результате выполнения функции
Ini
(m
0,
n
0,
M
0,
k
0) задаются значения переменных A.m, A.n,
A.M, A.k, выделяется память для A.M указателей на строки и выделяется память
для A.k строк.
Примечание
по работе Ini
:
Иногда
нет смысла сразу выделять память под строки. В этом случае можно написать:A.Ini(2, 2, 2).После выполнения функции Ini с тремя аргументами
будет присвоено A.k = 0, о чем не стоит забывать, т.к. A.k = 0 указывает на
матрицу из 0 строк; если мы хотим указать на матрицу из A.m строк, то A.k
должен быть не меньше
A
.
m
.
Можно
также сделать двухместный вызов этой функции:A.Ini(2, 2), в этом случае не будет выделена память для указателей на
строки и будет присвоено A.
M
= 0.
Так же
поступим с матрицами
B
и
C
:
B
.
Ini
(2, 2, 2, 2);
C
.
Ini
(2, 2, 2, 2);
Зададим
значения ячеек матриц
A
и B:
A.data = 1;
A.data = 2;
A.data = 3;
A.data = 4;
B.data = 5;
B.data = 6;
B
.
data
= 7;
B
.
data
= 8;
и,
наконец, сложим матрицы:
C
=
A
+
B
;
В
результате сложения в массиве C.data появится требуемый результат, который
можно вывести на экран. Например:
Label
1->
Caption
=
FloatToStr
(
C
.
data
);
- на форме отобразится значение ячейки
(1-я строка, 1-й столбец), равное 6.
После
получения результата и его выгрузки освободим память:
if(A.data)A.de_allocate();
if(B.data)B.de_allocate();
if(C.data)C.de_allocate();
Важное
замечание по поводу работы функции de_allocate():эта функция удаляет только строки в диапазоне
(k-m), … , ( k
-1)(имеются в виду индексы массива data в C++
коде, то есть нумерация идет с 0). То есть «рабочую» часть нашего стакана.Перед запуском de_allocate() надо быть
уверенным, что все прочие строки, лежащие вне данного диапазона, были удалены
ранее. В нашем примере k = m, поэтому функцию выполнять можно; вопрос
постепенного удаления «отслуживших» строк рассмотрим в следующем примере.
Исходный
код рассмотренного примера – .
Пример
2.
Предположим,
что требуется оценивать некоторую характеристику потока измерений, поступающих
в компьютер с внешних устройств. Например, это данные с
N
датчиков.
В каждый
момент времени имеем
N
значений, из которых можно составить строку матрицы, то есть можно сказать, что
на вход приходят строки. Пусть характеристика, которую надо вычислять –
детерминант. Для того, чтобы его вычислить, нам нужно иметь
N
строк, т.к. матрица должна быть
квадратной.
Опишем
матрицу и выделим память (только для указателей на строки):
X
.
Ini
(
N
,
N
, 10000);// Не указали
значение
k
- не выделилось место под строки
X
.
k
= 1;
while
(
X
.
k
<=
X
.
M
)
{
X
.
Allocate
(
X
.
k
- 1);// Выделяем память для строки
if
(
X
.
k
>
X
.
m
)
X
.
Delete
(
X
.
k
-
X
.
m
- 1);// Удаляем
последнюю использованную, но пока не удаленную строку
// Заполняем новую строку (симуляция
сигналов)
for(i = 0; i < N; i++)
X.data[i] = (((rand() %
RAND_MAX)+1.0)/RAND_MAX);//
Равномерно распределенная на случайная величина
if
(
X
.
k
>=
X
.
m
)
det
=
X
.
det
();// Появилось
m
строк - можно считать определитель
X
.
k
++;
}
Полный
текст пр
ограммы - . В
исходном коде добавлено умножение матрицы на себя, дискриминант берется от
матрицы-произведения. Отображение результатов на форме сделано с помощью
таймера.
Исходя
из значения X.M можно оценить, сколько раз в секунду Ваш компьютер находит
значение определителя матрицы размера
N
*
N
(всего определитель вычисляется (X.M-
N
+1) раз). Увеличивая размер матрицы, можно
получить представление о возможностях алгоритма.
Важное
замечание: в этом примере мы освобождали и выделяли память для строк на каждом
шаге. Для повышения быстродействия иногда имеет смысл перераспределять память с
интервалом в несколько шагов, большими кусками. То есть через несколько шагов
добавлять / удалять сразу по несколько строк матрицы.
Так как
функция de_allocate() освобождает память от строк с индексами из диапазона(k-m),
… , ( k
-1),
важно перед запуском функции указать правильное значение k. Для этого в
исходном коде после главного цикла указано:X.k--;
, чтобы сбросить последнее увеличение X.k на единицу.
Динамическая идентификация состояния системы
Для
демонстрации возможностей работы с классом предлагается пример (с исходниками) .
При
запуске программы (matrix.exe) открывается форма, на которой можно задавать
матрицы и производить простейшие операции с ними. В исходном тексте можно
увидеть, каким образом используется наш класс при программировании на C++.
При
нажатии на кнопку «Динамические операции» открывается форма для решения
следующей задачи.
Пусть у
нас есть 4 сигнала, поступающих на вход:X 1 , X 2 , X 3
и Y
. Мы предполагаем, что эти 4
переменные связаны между собой линейным уравнением:
C
1
* X 1 +
C
2
* X 2 +
C
3
* X 3 = Y
В качестве
одного или нескольких входных параметров может использоваться как физический
сигнал, так и расчетные величины, например, производные или отфильтрованные
данные.
Требуется
оценить в каждый момент времени коэффициенты состояния системы
C
1
,
C
2
,
C
3
, то
есть решить уравнение относительно C i
.
В
идеальных условиях, при отсутствии шума и при постоянных X 1 , X 2 , X 3
и Y
в каждый момент времени мы получаем одно и то же уравнение,
имеющее бесконечное множество решений. На практике мы имеем шум и изменяющиеся значения
сигналов, в результате чего получается система из большого количества
несовместных уравнений.
Для
приближенного решения несовместной системы существует несколько вычислительных
подходов; в нашей программе реализована комбинация 2-х методов:МНК (Метод наименьших квадратов) с
«коэффициентом экспоненциального забывания» и обобщенный проекционный алгоритм.
Использование
подхода МНК обусловлено необходимостью получения на каждом шаге невырожденной
матрицы для последующего решения системы уравнений проекционным алгоритмом. Для
увеличения гибкости настройки вводится коэффициент экспоненциального забывания
W
2
, смысл
которого состоит в усреднении вновь полученной методом МНК системы с
аналогичной системой, полученной на предыдущем шаге. Чем больше значение
W
2
, тем
больший вес имеют предыдущие значения. Коэффициент принадлежит интервалу ;
Если процесс – единственный,
этого делать не надо, по умолчанию
Thr
= 0.
То же касается и инициализации
объектов
LSM
и
PROJECTION. В этих классах в функциях инициализации добавлена еще одна
переменная (по умолчанию также равная 0):
LSMLsm;
Lsm
.Ini
(…,
…, [
номер
процесса
]);
PROJECTIONProjection
;
Projection
.
Ini
0(…, [номер процесса]);
Все исходники,
доступные к скачиванию с данной страницы, обновлены с учетом этих изменений.
I
. На кого рассчитан
модуль.
Данный модуль рассчитан учащегося в
старшей школе или студента. Должны быть
освоены такие темы как работа с циклами,
с указателями, необходимо знать, что
такое одномерный массив. II
. Мотивация
Мы уже знаем, для чего нам могут
понадобиться одномерные массивы.
Например, мы можем сохранить в одномерном
массиве коэффициенты квадратного
уравнения и посчитать корни, используя
дискриминант. А если нам нужно посчитать
много таких уравнений? Неужели каждый
раз перезаписывать новые коэффициенты
на место старых? А если необходимо будет
вернуться к уже посчитанным? Или нам
нужно решить систему из нескольких
уравнений, т.е. нужно одновременно
работать со всеми? Если нам просто нужно
хранить таблицу каких-то значений,
например, измерений при опыте, как нам
это сделать, используя полученные уже
знания? Для каждого из вышеназванных случаев
можно просто объявить несколько
одномерных массивов, но вот приятно ли
будет работать с таким количеством?
Ведь каждый нужно будет назвать и
обработать отдельно. Ситуация похожа
на ту, когда мы только вводили понятие
одномерного массива. Тут и приходят на
помощь массивы двумерные. Обычным представлением таких массивов
являются таблицы
значений, содержащие
информацию в строках
и столбцах.
Чтобы определить отдельный табличный
элемент, нужно указать два индекса:
первый (по соглашению) указывает номер
строки, а второй (опять же по соглашению)
указывает номер столбца. Рисунок иллюстрирует двумерный массив
a
.
Массив содержит
три строки и четыре столбца, так что,
еще говорят, - это массив три на четыре.
Вообще, массивы с m
строками и n
столбцами
называют массивами m
на n
.
Каждый элемент в массиве а
определяется
именем элемента в форме a
[
i
][
j
];
a
–
это имя
массива, а i
и j
– индексы, которые однозначно
определяют каждый элемент в а
.
Заметим, что имена элементов первой
строки имеют первый индекс 0
, имена
элементов в четвертом столбце имеют
второй индекс 3
. Неправильная ссылка на элемент двумерного
массива a
[
x
]
[
y
]
как a
[
x
,
y
].
На самом деле, a
[
x
,
y
]
воспринимается как a
[
y
]
,
потому что С оценивает выражение
(содержащее операцию последования -
запятую) x
,
y
просто как y
(последнее из разделенных запятыми
выражений). Многомерные массивы могут получать
начальные значения в своих объявлениях
точно так же, как массивы с естественным
индексом. Например, двумерный массив
b
можно объявить
и дать ему начальные значения таким
образом: int
b = {{1,2}, {3,4}}; Значения группируются в строки,
заключенные в фигурные скобки. Таким
образом, элементы b
иb
получают начальныезначения 1 и
2, а элементы b
и
b
получают
начальные значения 3 и 4. Если начальных
значений в данной строчке не хватает
для их присвоения всем элементам строки,
то остающимся элементам присваиваются
нулевые начальные значения. Таким
образом, объявление int b = {{1,},{3,4}}; будет означать, что b
получает начальное значение 1, b
получает начальное значение 0. Объем памяти в байтах, занимаемый
двухмерным массивом, вычисляется по
следующей формуле: Количество байтов =
размер_1-го_измерения*размер_2-го_измерения*sizeof(базовый
тип) Например, двумерный массив 4-байтовых
целых чисел размерностью 10*5 занимает
участок памяти объемом то есть 200 байтов. Передача массива в функцию.
Рассмотрим небольшую программу вывода
элементов двумерного массива: #include
void
printArray(int a) for (int i = 0; i<=1;i++) for (int
j=0; j<=2; j++) printf(“%i, ”,&a[i][j]); printf(“\n”); int array = {{1,2,3},{4,5,6}}; printf(“Values in array on rows:”); printgArray(array); Values
in array on rows:
Программа вызывает функцию printArray
для вывода элементов массива. Заметим,
что описание функции указывает параметр
– массив как int
a
. Когда мы задаем как аргумент
функции одномерный массив, скобки в
списке параметров функции пусты.
Размерность первого индекса многомерного
массива также не требуется, но все
последующие размерности индексов
необходимы. Компилятор использует
размерности этих индексов для определения
соответствующих ячеек памяти для доступа
к элементам многомерных массивов. В
памяти все элементы массива хранятся
последовательно, независимо от количества
индексов (размерности массива). В
двумерном массиве первая строка хранится
в памяти перед второй строкой. Наличие размерностей индексов в
объявлении параметра дает возможность
компилятору сообщить функции о том, как
расположены элементы в массиве. В
двумерном массиве каждая строка является
одномерным массивом. Чтобы определить
местоположение элемента в некоторой
строке, функция должна точно знать,
сколько элементов находится в каждой
строке. Тогда функция может пропустить
соответствующее количество ячеек памяти
при обращении к массиву. Таким образом,
при обращении к a
функция знает, что для доступа ко
второй строке (строка 1) нужно пропустить
в памяти три элемента первой строки, а
затем обратиться к третьему элементу
этой строки (элементу 2). Многие типовые операции с массивами
используют конструкцию for
.
Так, следующий цикл определяет сумму
всех элементов массива a
: for
(row = 0; row < 3; row++) for (column = 0; column < 3; column ++) total += a ; Внутренняя структура for
суммирует элементы одной строки
массива. Внешняя структура for
начинает работу с установки row
(т.е. индекса строки) в нуль, так что во
внутренней структуре for
могут быть просуммированы элементы
второй строки. Далее внешняя структура
for
увеличивает
row
до значения 2,
так что могут быть просуммированы
элементы третьей строки. После завершения
работы вложенной структурыfor
печатается результат. Задача
Учащиеся одного из ВУЗов как-то поспорили,
у кого наивысший средний бал за только
что сданную сессию. Заодно захотели
выяснить, кто получил наилучшую и
наихудшую оценки. Для интереса представим,
что мы живем в Америке, и оценки
выставляются по 100-бальной шкале. Указание: Программа должна «знать» имена студентов,
выводить их на экран. То же самое с
таблицей успеваемости. Подразумевается,
что номера столбцов эквивалентны номерам
экзаменов. Размышления о решении задачи
Для начала давайте определимся, что нам
нужно для решения этой задачи. Первое,
на что мы обращаем внимание – это то,
что в условие явно сказано слово
«таблица». Значит, скорее всего, для
работы с ней мы будем использовать
двумерный массив. Каждая строка в нем
– это успеваемость отдельного студента.
Как и сказано в условии, номер столбца
будет определять номер сданного экзамена,
номер строки – студента. Именно с этим
массивом мы и будем работать, вычисляя
средний бал, минимум и максимум. Видно,
что необходимо будет создать три функции
для получения нужных нам данных и функцию
вывода таблицы оценок на экран. Все, что
нужно для написания этой части программы,
мы уже знаем. Теперь разберемся с именами. Неплохо
было бы их скомпоновать в таблицу, для
того, чтобы по номеру студента можно
было определить его имя и наоборот. Мы
уже знаем. Что строка – это одномерный
массив символов. Значит, можно создать
двумерный массив, в котором номер строки
будет определять номер студента, а номер
столбца – соответствующую букву имени.
Но тогда придется создать массив с
наибольшим количеством ячеек по
горизонтали из возможных. Т.е., если у
нас есть четыре студента: То необходимо будет создать таблицу,
подобную изображенной на рисунке: Серым цветом на рисунке показаны пустые
клетки нашего массива. На эти клетки
будет отведено место в памяти, но вот
пользоваться они не будут. Так зачем
они нам нужны? Нет ли способа избежать
такой ситуации? Оказывается, есть. Об
этом будет рассказано ниже, а затем мы
вернемся к решению нашей задачи. Аннотация:
Приводятся правильные и неправильные способы реализации матриц и многомерных массивов на языке Си. Работа с матрицами иллюстрируется на примере приведения матрицы к ступенчатому виду методом Гаусса. Рассматриваются методы работы с файлами, использующие функции ввода-вывода из стандартной библиотеки ANSI. Приводятся способы работы с символами и текстовыми строками с помощью функций стандартной библиотеки. Материал иллюстрируется примерами, включающими программу "wc" подсчета символов, слов и строк в файле и программу "Записная книжка", которая позволяет находить телефон человека по его имени, а также сохранять и модифицировать содержимое книжки.
Специального типа данных
матрица
или многомерный массив
в Си
нет, однако, можно использовать массив
элементов типа массив
. Например, переменная
a
представляет матрицу размера 3x3
с вещественными элементами: Элементы матрицы располагаются в памяти последовательно по
строкам: сначала идут элементы строки с индексом 0, затем строки с индексом 1, в конце строки с индексом 2 (в программировании отсчет индексов всегда начинается с нуля, а не с единицы!). При этом выражение
где i
-- целая переменная
, представляет собой указатель
на начальный элемент i
-й строки и имеет тип double*
. Для обращения к элементу матрицы надо записать его индексы в квадратных скобках, например, выражение
представляет собой элемент матрицы a
в строке с индексом i
и столбце с индексом j
. Элемент матрицы можно использовать в любом выражении как обычную переменную (например, можно читать его значение
или присваивать новое). Такая реализация матрицы удобна и максимально эффективна с точки зрения времени доступа к элементам. У нее только один существенный недостаток: так можно реализовать только матрицу, размер которой известен заранее. Язык Си
не позволяет описывать массивы переменного размера, размер массива должен быть известен до начала работы программы еще на стадии компиляции. Пусть нужна матрица
, размер которой определяется во время работы программы. Тогда пространство
под нее надо захватывать в динамической памяти с помощью функции malloc
языка Си
или оператора new
языка C++. При этом в динамической памяти захватывается линейный массив
и возвращается указатель
на него. Рассмотрим вещественную матрицу размером m
строк на n
столбцов. Захват
памяти выполняется с помощью функции malloc
языка Си
double *a;
. . .
a = (double *) malloc(m * n * sizeof(double)); или с помощью оператора new
языка C++: double *a;
int m, n;
. . .
a = new double; При этом считается, что элементы матрицы будут располагаться в массиве следующим образом: сначала идут элементы строки с индексом 0
, затем элементы строки с индексом 1
и т.д., последними идут элементы строки с индексом m - 1
. Каждая строка состоит из n элементов, следовательно, индекс
элемента строки i
и столбца j
в линейном массиве равен (действительно, поскольку индексы начинаются с нуля, то i
равно количеству строк, которые нужно пропустить, i * n
- суммарное количество элементов в пропускаемых строках; число j
равно смещению внутри последней строки). Таким образом, элементу матрицы в строке i
и столбце j
соответствует выражение
Этот способ представления матрицы удобен и эффективен. Его основное преимущество состоит в том, что элементы матрицы хранятся в непрерывном
отрезке памяти. Во-первых, это позволяет оптимизирующему компилятору преобразовывать текст программы, добиваясь максимального быстродействия; во-вторых, при выполнении программы максимально используется механизм кеш
-памяти, сводящий к минимуму обращения к памяти и значительно ускоряющий работу программы. В некоторых книгах по
Си
рекомендуется реализовывать матрицу как массив
указателей на ее строки, при этом память
под каждую строку захватывается отдельно в динамической памяти: double **a; // Адрес массива указателей
int m, n; // Размеры матрицы: m строк, n столбцов
int i;
. . .
// Захватывается память под массив указателей
a = (double **) malloc(m * sizeof(double *));
for (i = 0; i < m; ++i) {
// Захватывается память под строку с индексом i
a[i] = (double *) malloc(n * sizeof(double));
} После этого к элементу a
ij можно обращаться с помощью выражения Несмотря на всю сложность этого решения, никакого выигрыша нет, наоборот, программа
проигрывает в скорости! Причина состоит в том, что матрица
не хранится в непрерывном участке памяти, это мешает как оптимизации программы, так и эффективному использованию кеш
-памяти. Так что лучше не применять такой метод представления матрицы. Многомерные массивы реализуются аналогично матрицам. Например, вещественный трехмерный массив
размера 4 x 4 x 2
описывается как обращение к его элементу с индексами x
, y
, z
осуществляется с помощью выражения Многомерные массивы переменного размера с числом индексов большим двух встречаются в программах довольно редко, но никаких проблем с их реализацией нет: они реализуются аналогично матрицам. Например, пусть надо реализовать трехмерный вещественный массив
размера m x n x k
. Захватывается линейный массив
вещественных чисел размером m * n * k
: double *a;
. . .
a = (double *) malloc(m * n * k * sizeof(double)); Доступ
к элементу с индексами x
, y
, z
осуществляется с помощью выражения a[(x * n + y) * k + z] В качестве примера работы с матрицами рассмотрим алгоритм Гаусса
приведения матрицы к ступенчатому виду. Метод Гаусса
- один из основных результатов линейной алгебры и аналитической геометрии, к нему сводятся множество других теорем и методов линейной алгебры (теория и вычисление
определителей, решение систем линейных уравнений, вычисление
ранга матрицы и обратной матрицы, теория базисов конечномерных векторных пространств и т.д.). Напомним, что матрица
A
с элементами a ij
называется ступенчатой, если она обладает следующими двумя свойствами: Ступенчатая матрица
выглядит примерно так: здесь тёмными квадратиками отмечены первые ненулевые элементы строк матрицы. Белым цветом изображаются нулевые элементы, серым цветом - произвольные элементы. Алгоритм Гаусса
использует элементарные преобразования матрицы двух типов. Элементарные преобразования сохраняют определитель
и ранг
матрицы, а также множество решений линейной системы. Алгоритм Гаусса
приводит произвольную матрицу элементарными преобразованиями к ступенчатому виду. Для ступенчатой квадратной матрицы определитель
равен произведению диагональных элементов, а ранг
- числу ненулевых строк (рангом по
определению называется размерность
линейной оболочки строк
матрицы). Метод Гаусса
в математическом варианте состоит в следующем: Программистский вариант метода Гаусса имеет три отличия от математического: r = -a kj /a ij .
a
k = a
k + r * a
i Такая схема работает нормально только тогда, когда коэффициент r
по
абсолютной величине не превосходит единицы. В противном случае, ошибки округления умножаются на большой коэффициент и, таким образом, экспоненциально растут. Математики называют это явление неустойчивостью
вычислительной схемы. Если вычислительная схема неустойчива, то полученные с ее помощью результаты не имеют никакого отношения к исходной задаче. В нашем случае схема устойчива, когда коэффициент r = -a kj /a ij
не превосходит по
модулю единицы. Для этого должно выполняться неравенство
|a ij | >= |a kj | при k > i Отсюда следует, что при поиске разрешающего элемента в j
-м столбце необходимо найти не первый попавшийся ненулевой элемент, а максимальный по абсолютной величине
. Если он по
модулю не превосходит , то считаем, что все элементы столбца нулевые; иначе меняем местами строки, ставя его на вершину столбца, и затем обнуляем столбец элементарными преобразованиями второго рода. Ниже дан полный текст программы на Си
, приводящей вещественную матрицу к ступенчатому виду. Функция
, реализующая метод Гаусса
, одновременно подсчитывает и ранг
матрицы. Программа
вводит размеры матрицы и ее элементы с клавиатуры и вызывает функцию приведения к ступенчатому виду. Затем программа
печатает ступенчатый вид матрицы и ее ранг
. В случае квадратной матрицы также вычисляется и печатается определитель матрицы
, равный произведению диагональных элементов ступенчатой матрицы. При реализации метода Гаусса используется схема построения цикла
с помощью инварианта, см. раздел 1.5.2. В цикле меняются две переменные -- индекс
строки i
, 0 =< i < m - 1
, и индекс
столбца j
, 0 =< j < n - 1
. Инвариантом цикла
является утверждение о том, что часть матрицы (математики говорят минор
) в столбцах 0,1,...j - 1
приведена к ступенчатому виду и что первый ненулевой элемент в строке i - 1
стоит в столбце с индексом меньшим j
. В теле цикла
рассматривается только минор матрицы в строках i,...,m - 1
и столбцах j,...,n - 1
. Сначала ищется максимальный по
модулю элемент в j
-м столбце. Если он по
абсолютной величине не превосходит то j
увеличивается на единицу (считается, что столбец нулевой). Иначе перестановкой строк разрешающий элемент ставится на вершину j
-го столбца минора, и затем столбец обнуляется элементарными преобразованиями второго рода. После этого оба индекса i
и j
увеличиваются на единицу. Алгоритм
завершается, когда либо i = m
, либо j = n
. По
окончании алгоритма значение
переменной i
равно числу ненулевых строк ступенчатой матрицы, т.е. рангу исходной матрицы. Для вычисления абсолютной величины вещественного числа x
типа double
мы пользуемся стандарной математической функцией fabs
(x)
, описанной в стандартном заголовочном файле " math
.h. #include Замечание 1
Пример
Замечание 2
Следует только пронаблюдать, как изменяются расстояния между элементами, лежащими один под другим, при движении вниз по строкам матрицы, что позволит легко перенести алгоритм на линейное представление верхней треугольной матрицы. Предлагаем читателю самому проделать это несложное, но наглядное упражнение, для лучшего понимания алгоритма.III. Изложение материала модуля
Типичная ошибка программирования
Представление матриц и многомерных массивов
Пример: приведение матрицы к ступенчатому виду методом Гаусса
Настройка и подключение приставки цифрового телевидения
Настройка и подключение приставки цифрового телевидения
Беспроводная акустика JBL GO Black (JBLGOBLK) - Отзывы Внешний вид и элементы управления
Виртуальный компьютерный музей Dx связь