Работа с двумерными числовыми массивами

Введение

1. Теоретическая часть

1.1 Общее понятие о массивах

1.1.1 Определение и область применения

1.1.2 Специфические типы массивов

1.1.3 Реализация массивов

1.1.4 Достоинства массивов

1.1.5 Недостатки массивов

1.2 Массивы в Object Pascal

1.2.1 Статические массивы

1.2.2 Динамические массивы

1.2.3 Функции для работы с массивами

1.3 Использование массивов в рамках проекта

2. Практическая часть

2.1 Постановка задачи

2.2 Функциональная структура приложения

2.3 Описание модулей

2.3.1 Модуль MatrixOperations

2.3.2 Модуль fileIO

2.4 Модуль form

3. Эксплуатационная документация

3.1 Описание применения

3.2 Руководство оператора

Выводы

Приложения

Введение

В
вычислительной технике данные обычно отличают от программ. Программа является
набором инструкций, которые детализируют вычисление или задачу, производимую
компьютером. Данными же традиционно называется всё, что не выступает в роли
программы. В языках высокого уровня данные воплощаются в виде переменных.

Часто перед
программистами встают задачи, связанные с обработкой стразу множества значений
данных. В таких случаях крайне неудобно для хранения каждого значения заводить
отдельную именованную переменную. Для такой ситуации синтаксис многих языков
предусматривает создание массивов – множеств переменных, доступ к
которым осуществляется посредством одного имени (имени массива) и одного или
нескольких индексов.

Данная
курсовая работа рассматривает методики использования многомерных массивов в
среде Delphi. Она демонстрирует использование
встроенных возможностей языка, а так же применение широко известных операций
над массивами, таких как последовательный обход значений, сортировка,
циклический сдвиг.

1. Теоретическая часть

1.1 Общее понятие о массивах

1.1.1 Определение и область
применения

Массив (или индексный массив), это
именованный набор однотипных переменных, расположенных в памяти непосредственно
друг за другом, доступ к которым осуществляется по индексу. Количество
используемых индексов массива может быть различным. Массивы с одним индексом
называют одномерными, с двумя — двумерными и т. д. Одномерный массив нестрого
соответствует вектору в математике, двумерный — матрице. Массивы хорошо
подходят для отображения таких объектов реального мира, как строки (массивы
символов), наборы координат, таблицы данных, математические множества и вообще
множества однотипных объектов.

Без использования
массивов не обойтись в таких областях программирования как работа с базами
данных, компьютерная графика, визуализация результатов научных экспериментов, статистический
анализ. Массивы являются входными и выходными параметрами процедур сортировки.

Поддержка
индексных массивов (свой синтаксис объявления, функции для работы с элементами
и т. д.) есть в большинстве высокоуровневых языков программирования.
Максимально допустимая размерность массива, типы и диапазоны значений индексов,
ограничения на типы элементов определяются языком программирования и/или
конкретным транслятором.

В языках
программирования, допускающих объявления программистом собственных типов, как
правило, существует возможность создания типа «массив». В определении такого
типа может указываться размер, тип элемента, диапазон значений и типы индексов.
В дальнейшем возможно определение переменных созданного типа. Все такие
переменные-массивы имеют одну структуру. Некоторые языки поддерживают для
переменных-массивов операции присваивания (когда одной операцией всем элементам
массива присваиваются значения соответствующих элементов другого массива).

1.1.2 Специфические типы массивов

Динамическим называется массив, размер которого
может меняться во время исполнения программы. Для изменения размера
динамического массива язык программирования, поддерживающий такие массивы,
должен предоставлять встроенную функцию или оператор. Динамические массивы дают
возможность более гибкой работы с данными, так как позволяют не прогнозировать
хранимые объёмы данных, а регулировать размер массива в соответствии с реально
необходимыми объёмами. Обычные, не динамические массивы называют ещё статическими.

Гетерогенным называется массив, в разные элементы
которого могут быть непосредственно записаны значения, относящиеся к различным
типам данных. Массив, хранящий указатели на значения различных типов, не
является гетерогенным, так как собственно хранящиеся в массиве данные относятся
к единственному типу — типу «указатель». Гетерогенные массивы удобны как универсальная
структура для хранения наборов данных произвольных типов. Отсутствие их
поддержки в языке программирования приводит к необходимости реализации более
сложных схем хранения данных. С другой стороны, реализация гетерогенности
требует усложнения механизма поддержки массивов в трансляторе языка.

Многомерные массивы, как правило, реализованные
как одномерные массивы, каждый элемент которых является ссылкой на другой
одномерный массив.

1.1.3 Реализация массивов

Стандартным
способом реализации статических массивов с одним типом элементов является
следующий:

Под массив
выделяется непрерывный блок памяти объёмом

S*m1*m2*m3…mn,

где S —
размер одного элемента, а m1…mn — размеры диапазонов
индексов (то есть количество значений, которые может принимать соответствующий
индекс).

При
обращении к элементу массива A[i1, i2, i3, … in]
адрес соответствующего элемента вычисляется как

B+S*(i1p*m1+i2p*m2+…+i(n-1)p*mn-1+inp),

где B — база
(адрес начала блока памяти массива), ikp-значение k-го индекса,
приведённое к целому с нулевым начальным смещением.

Таким
образом, адрес элемента с заданным набором индексов вычисляется так, что время
доступа ко всем элементам массива одинаково. Первый элемент массива, в
зависимости от языка программирования, может иметь различный индекс. Различают
три основных разновидности массивов: с отсчетом от нуля (zero-based), с
отсчетом от единицы (one-based) и с отсчетом от специфического значения
заданного программистом (n-based).

Отсчет
индекса элемента массивов с нуля более характерен для низкоуровневых языков
программирования, однако этот метод был популяризирован в языках более высокого
уровня языком программирования С.

Более
сложные типы массивов — динамические и гетерогенные — реализуются сложнее.

1.1.4 Достоинства массивов

·         
Быстрый доступ к
элементам, причём время доступа не зависит от длины массива

·         
Элементы
расположены в памяти непосредственно друг за другом, что облегчает копирование
и перемещение всего массива целиком

·         
Отсутствие
необходимости в дополнительной памяти

1.1.5 Недостатки массивов

·         
для статического
массива — отсутствие динамики, невозможность удаления или добавления элемента
без сдвига других

·         
для динамического
и/или гетерогенного массива — более низкое (по сравнению со статическим)
быстродействие и дополнительные накладные расходы на поддержку динамических
свойств и/или гетерогенности.

·         
при работе с
массивом в отсутствие дополнительных средств контроля — угроза выхода за
границы массива и повреждения «чужих» данных

1.2 Массивы в Object Pascal

Ключевое
слово Array используется для определения
одномерных и многомерные массивов данных. В Object Pascal существует два типа массивов

1.2.1 Статические массивы

Создаются с
заранее определёнными, неизменяемыми размерами. Могут быть одномерными, или
многомерными – во втором случае представляя из себя массив массивов (массивов
массивов и так далее).

Величина
каждой размерности определяется двумя способами, которые могут свободно
сочетаться при определении многомерного массива:

·         
Тип Index, где Index – целый тип, обычно Byte или Word.
Диапазон типа определяет диапазон размерности, например 0..255 для Byte

·         
Ordinal..Ordinal. Таким образом, можно непосредственно задать диапазон
размерности, например 12..44.

·         
Например:

1    
var

2    
wordArray : Array[Word] of Integer; // размер
равен
High(Word)

3    
multiArray : Array[Byte, 1..5] of char; //
двумерный
массив

4    
rangeArray : Array[5..20] of string; // размер
равен
16

1.2.2 Динамические массивы

У для
динамических массивов память заранее не выделяется, создаётся только указатель.
У таких массивов необходимо задавать размер перед использованием. Например

SetLength(dynArray, 5);

устанавливает
длину первой размерности массива dynArray в пять, при этом выделяется необходимая память. Для всех динамических
массивов минимальный индекс равен нулю.

Отдельные
подмассивы многомерного динамического массива могут иметь разные размеры, так
как по сути они являются отдельными массивами.

Пример
определения динамических массивов:

1         
var

2         
byteArray: Array of Byte; // одномерный
массив

3         
multiArray: Array of Array of string; //
двумерный
массив

1.2.3 Функции для работы с массивами

Copy
(Source : array; StartIndex, Count : Integer ) : array – создает копию части массива.

High
(type or variable): Ordinal type - возвращает верхнюю границу диапазона значений массива.

Length (const SourceArray: array): Integer
- возвращает число элементов в массиве.

Low
(type or variable): Ordinal type - возвращает нижнюю границу
диапазона значений массива

SetLength (var ArrayToChange: Array type; Dim1Length: Integer {;Dim2Length:
Integer; ...}) -
изменяет размер динамического массива. Для многомерных массивов может принимать
более одного параметра длины.

Slice (SourceArray: array; Count: Integer):
array - создает часть массива для передачи его как параметр в процедуру или
функцию.

При
использовании динамических массивов необходимо помнить, что вызовы SetLength выделяют для массива дополнительную
память, которую необходимо освобождать после окончания работы с массивом. Для
этого ему нужно присвоить специальное значение nil.

1.3 Использование массивов в рамках
данного проекта

Работа со
статическими массивами более проста и менее затратна в плане использования
ресурсов компьютера, но так как в задании нигде не оговариваются конкретные
размеры исходных матриц, то было принято решение построить программу ну основе
использования динамических массивов.

Приложение построено
таким образом, что размер используемой матрицы можно менять во время
выполнения, так же он автоматически определяется при загрузке исходных данных
из файла. Размеры динамических массивов внутри программы изменяются
соответствующим образом автоматически.

2. Практическая часть

2.1 Постановка задачи

Приложение
предназначено для выполнения специфической обработки матриц. Исходные матрицы
должны загружаться из файла, либо вводиться непосредственно в элементы
интерфейса приложения.

Граничные
условия на вводимые данные таковы:

·         
Размеры матрицы
должны лежать в пределах [1; 2147483647]. Если введено число, выходящее из
этого диапазона, либо значение, не являющееся целым числом, то размер
устанавливается равным единице.

·         
Элементы матрицы
должны лежать в пределах [-2147483648; 2147483647]. Если какой-то из элементов
лежит вне этого диапазона, либо введёно значение, не являющееся целым числом,
то элемент устанавливается равным нулю.

·         
В заданиях,
связанных с подсчётом сумм элементов, результат может лежать в пределах
[-9223372036854775808; 9223372036854775807]. Если сумма выходит за эти пределы,
результат не определён.

2.2 Функциональная структура
программы

Программа
разделена на три модуля:

MatrixOperations – различные операции с матрицей

fileIO – сохранение матрицы в файл/ чтение
матрицы из файла

form – форма приложения, процедуры обмена
данными между массивами и элементами формы. Структура связей модулей такова:

2.3 Описание модулей

2.3.1 Модуль MatrixOperations

Это основной
модуль программы, содержащий процедуры для выполнения матричных операций,
предусмотренных заданием.

Определяет
повсеместно используемые типы «матрица» и «вектор»:

1           
type

2           
TVector = array of integer;

3           
TMatrix = array of TVector;

Поиск
максимальных элементов в матрице.

Процедура GetMaxVals,
которая, перебирая все строки матрицы, находит в каждой максимальный элемент,
записывает его значение в массив maxVal, а его номер столбца в массив
maxValCol. Предварительно процедура выделяет необходимую намять для этих
массивов. Листинг:

1 {

2           
формирует
массив максимальных элементов maxVal
и массив номеров столбцов,

3           
содержащих
максимальные элементы maxValCol
на основе матрицы arr

4           
}

5           
procedure GetMaxVals(var maxVal,
maxValCol: TVector; const arr: TMatrix);

6           
var

7           
RowN, ColN, maxInRow: integer;

8           
begin

9           
//выделим
необходимый для каждого массива объём памяти

10         
SetLength(maxVal, high(arr)+1);

11         
SetLength(maxValCol, high(arr)+1);

12         
for RowN:= low(arr) to high(arr) do

13         
begin//для каждой строки

14         
maxVal[RowN]:=
low(integer);//по
умолчанию максимальное значение -2147483648

15         
maxValCol[RowN]:=
-1;//по умолчанию номер столбца с макс элементом -1

16         
for ColN:= low(arr[RowN]) to
high(arr[RowN]) do

17         
begin//для каждого столбца

18         
if arr[RowN, ColN] > maxVal[RowN]
then

19         
begin//если элемент больше
макс значения, то

20         
maxVal[RowN]:=
arr[RowN,
ColN];//максимальное значение
приравняем элементу

21         
maxValCol[RowN]:=
ColN;//номер столбца приравняем
текущему столбцу

22         
end;

23         
end;

24         
end;

25         
end;

Суммы
элементов между диагоналями

Далее идут
функции, осуществляющие подсчёт сумм элементов выше и ниже пересечения
диагоналей, а так же смену местами этих элементов. Главной диагональю считается
множество элементов матрицы, индексы которых совпадают, побочной диагональю
считается та, которая идёт по диагонали из нижнего левого угла матрицы.

Функции GetSumAbove и GetSumBelow проходят соответствующие половины
строк матрицы, для каждой строки высчитывая диапазон столбцов, из которых нужно
суммировать элементы:

1         
{возвращает
сумму элементов выше пересечения диагоналей матрицы arr}

2         
function GetSumAbove (const arr:
TMatrix): Int64;

3         
var

4         
RowN, ColN: integer;

5         
lastColumn: integer;//номер
столбца, содержащего элемент дальней диагонали минус 1

6         
begin

7         
Result:= 0;

8         
for RowN:= 0 to (high(arr) div 2) do

9         
begin//с нулевой, по средюю
строку

10       
lastColumn:= high(arr)-RowN-1;//определим
номер столбца последнего элемента, подлежащего суммированию

11       
//если
число столбцов меньше числа строк, то последний столбец может оказаться ближе

12       
if lastColumn > high(arr[RowN]) then
lastColumn:= high(arr[RowN]);

13       
for ColN:= RowN+1 to lastColumn do //просуммируем
элементы
в высчитаных
пределах

14       
Result:= Result + arr[RowN, ColN];

15       
end;

16       
end;

17       
{возвращает
сумму элементов ниже пересечения диагоналей матрицы arr}

18       
function GetSumBelow(const arr:
TMatrix): Int64;

19       
var

20       
RowN, ColN: integer;

21       
lastColumn: integer;//номер
столбца, содержащего элемент дальней диагонали минус 1

22       
begin

23       
Result:= 0;

24       
for RowN:= (high(arr) div 2)+1 to
high(arr) do

25       
begin//со средней по
последнюю строку

26       
lastColumn:= RowN-1;//определим
номер столбца последнего элемента, подлежащего суммированию

27       
//если
число столбцов меньше числа строк, то последний столбец может оказаться ближе

28       
if lastColumn > high(arr[RowN]) then
lastColumn:= high(arr[RowN]);

29       
for ColN:= high(arr)-RowN+1 to
lastColumn do //просуммируем элементы в высчитаных пределах

30       
Result:= Result + arr[RowN, ColN];

31       
end;

32       
end;

Процедура SwapAboveBelow
таким же образом, как функция GetSumAbove, определяет, какие элементы лежат выше пересечения
диагоналей, но не суммирует их, а каждый меняет местами с элементом того же
столбца, симметричным текущему относительно верхней и нижней границ матрицы.
Для смены используется вспомогательная процедура swap для целых чисел, определённая в этом
же модуле:

1    
{вспомогательная
процедура: поменять местами два целых числа}

2    
procedure swap(var first, second:
integer);

3    
var tmp: integer;

4    
begin

5    
tmp:= first;

6    
first:= second;

7    
second:= tmp;

8    
end;

9    
{поменять
местами элементы выше и ниже пересечения диагоналей матрицы arr}

10  
procedure SwapAboveBelow (var arr:
TMatrix);

11  
var

12  
RowN, ColN: integer;

13  
lastColumn: integer;//номер
столбца, содержащего элемент дальней диагонали минус 1

14  
begin

15  
for RowN:= 0 to (high(arr) div 2) do

16  
begin//с нулевой, по средюю
строку

17  
lastColumn:= high(arr)-RowN-1;//определим
номер столбца последнего элемента, подлежащего суммированию

18  
//если
число столбцов меньше числа строк, то последний столбец может оказаться ближе

19  
if lastColumn > high(arr[RowN]) then
lastColumn:= high(arr[RowN]);

20  
for
ColN:= RowN+1
to lastColumn
do//для каждого элемента в высчитаных
пределах

21  
//поменяем
его местами с элементом того же столбца, отстаящем на то же число строк, но от
нижней границы матрицы

22  
swap(arr[RowN, ColN], arr[high(arr) -
RowN, ColN]);

23  
end;

24  
end;

Циклический
сдвиг строк

Далее
функция CircuarShift, осуществляющая циклический сдвиг строк матрицы
вверх, или вниз. Направление сдвига определяется булевым параметром shiftUp,
передаваемым процедуре:

1  
{

2  
осуществляет
циклический сдвиг строк матрицы arr
вверх при shiftUp = true,

3  
и вниз, при shiftUp = false

4  
}

5  
procedure CircuarShift(var arr: TMatrix;
shiftUp: boolean);

6  
var

7  
RowN: integer;

8  
tmpRow: TVector;//временная
переменная для хранения строки иатрицы

9  

10           
begin

11           

12           
if
high(arr)
< 1 then
exit;//если в матрице меньше двух строк
- выходим

13           
if shiftUp then

14           
begin//если сдвиг вверх

15           
tmpRow:= arr[high(arr)];//сохраним
последнюю строку матрицы

16           
arr[high(arr)]:= arr[0];//приравняем
последнюю строку первой

17           
for rowN:= 0 to high(arr)-2 do

18           
begin//для строк с нулевой
по пред-предпоследнюю

19           
arr[rowN]:=
arr[rowN+1];//текущая
строка равна нижней

20           
end;

21           
arr[high(arr)-1]:=
tmpRow;//предпоследнюю строку
приравняем последней

22           
end

23           
else

24           
begin//иначе, если сдвиг вниз

25           
tmpRow:= arr[0];//сохраним нулвую строку

26           
arr[0]:= arr[high(arr)];//приравняем
нулевую строку последней

27           
for rowN:= high(arr) downto 2 do

28           
begin//для строк с последней
по вторую

29           
arr[RowN]:=
arr[RowN-1];//текущая
строка равна верхней

30           
end;

31           
arr[1]:= tmpRow;//первую
строку приравняем нулевой

32           
end;

33           
end;

«Разворачивание»
матрицы

Процедура UnwindMatrix
осуществляет "разворачивание" матрицы в одномерный массив против
часовой стрелки. Эта процедура в своих локальных переменных хранит координаты
текущего элемента, текущее направление обхода (посредством перечислимого типа
TDirection), а так же границы ещё не обойдённой части матрицы, которые сужаются
каждый раз, когда проходится целая строка, или столбец. В этот же момент
меняется направление обхода и текущим становится элемент в этом направлении.
Обход завершается, когда число пройденных элементов станет равняться количеству
элементов в матрице:

1  
//перечисление - направления

2  
type TDirection = (down, right, up,
left);

3  

4  
{обходит
матрицу arr против часовой стрелки
и наполняет элементами массив res}

5  
procedure UnwindMatrix(const arr:
TMatrix; var res: TVector);

6  
var

7  
count, cur:
integer;//число элементов в
матрице и счётчик элементов

8  

9  
RowN, ColN:
integer;

10           
leftB, bottomB,
rightB, topB:
integer;//границы обхода -
меняются при проходе полной строки или столбца

11           
direction: TDirection;//текущее
направление обхода

12           

13           
begin

14           
if (length(arr)
= 0) or (length(arr[0])
= 0) then
exit;//если в матрице нет элементов -
выходим

15           
count:= length(arr)
* length(arr[0]);//подсчитаем
число элементов в матрице

16           
SetLength(res,
count);//выделим память для
хранения всех элементов матрицы

17           

18           
//начальные
условия обхода: текущий элемент [0,0], границы совпадают с граниуцами матриы,
направление - вниз

19           
direction:= down;

20           
RowN:= 0;

21           
ColN:= 0;

22           
leftB:= 0;

23           
bottomB:= high(arr);

24           
rightB:= high(arr[0]);

25           
topB:= 0;

26           

27           
for cur:= 0 to count-1 do

28           
begin//пока не пройдём count
элементов

29           
res[cur]:=
arr[RowN,
ColN];//добавляем текущий элемент в
массив

30           
//дальненйшие
действия зависят от текущего направления обхода

31           
case direction of

32           
down://если вниз

33           
if
RowN < bottomB
then inc(RowN)//если
не дошли до нижней границы - сдвигаемся вниз

34           
else

35           
begin//иначе - прошли левый столбец

36           
direction:= right;//сменим
направление на "вправо"

37           
inc(leftB);//сдвинем
левую границу к центру

38           
inc(ColN);//сдвинемся вправо

39           
end;

40           

41           
right://если вправо

42           
if
ColN < rightB
then inc(ColN)//если
не дошли до правой границы - сдвигаемся вправо

43           
else

44           
begin//иначе - прошли нижнюю строку

45           
direction:= up;//сменим
направление на "вверх"

46           
dec(bottomB);//сдвинем
нижнюю границу к центру

47           
dec(RowN);//сдвинемся вверх

48           
end;

49           

50           
up://если вверх

51           
if
RowN > topB
then dec(RowN)//если
не дошли до верхней границы - сдвигаемся вверх

52           
else

53           
begin//иначе - прошли правый столбец

54           
direction:= left;//сменим
направление на "влево"

55           
dec(rightB);//сдвинем
правую границу к центру

56           
dec(ColN);//сдвинемся влево

57           
end;

58           

59           
left://если влево

60           
if
ColN > leftB
then dec(ColN)//если
не дошли до левой границы - сдвигаемся влево

61           
else

62           
begin//иначе - прошли верхнюю строку

63           
direction:= down;//сменим
направление на "вниз"

64           
inc(topB);//сдвинем
верхнюю границу к центру

65           
inc(RowN);//сдвинемся вниз

66           
end;

67           
end;

68           
end;

69           
end;

Сортировка
строк матрицы

Наконец
упорядочивание строк матрицы по убыванию суммы элементов каждой строки.
Вспомогательная функция getRowSum возвращает сумму элементов заданной
строки:

1  
{возвращает
сумму элементов RowN-ой строки
матрицы arr}

2  
function getRowSum(const arr: TMatrix;
RowN: integer): Int64;

3  
var ColN: integer;

4  
begin

5  
Result:= 0;

6  
if
RowN > high(arr)
then exit;//если
в матрице нет RowN-ой строки - выходим

7  
for ColN:= 0 to high(arr[RowN])
do//суммируем элементы строки

8  
Result:= Result + arr[RowN, ColN];

9  
end;

Сама
сортировка осуществляется посредством процедуры SortRows. Был выбран
алгоритм прямой вставки, так как число строк в матрице не предполагается
большим, а этот алгоритм эффективен на небольших наборах данных. В любом случае
сортировка осуществляется быстро, так как при перемене мест строк не происходит
копирование данных, но просто переставляются местами указатели. Листинг этой
функции:

1  
{сортирует
строки матрицы по убыванию сумм элементов каждой строки}

2  
procedure SortRows(var arr: TMatrix);

3  
var

4  
i, k:
integer;//переменные для
алгоритма сортировки

5  
tmpRow: TVector;//временная
переменная для алгоритма сортировки

6  
begin

7  
//алгоритм
сортировки методом прямой вставки

8  
for i:= 1 to high(arr) do

9  
begin//для строк с первой по
последнюю

10           
k:= i;//начиная
с текущей строки

11           
while (k > 0) and (getRowSum(arr, k)
> getRowSum(arr, k-1)) do

12           
begin//пока не дошли до
нулевой строки, и сумма строки над текущей строкой больше текущей суммы

13           
swap(arr[k-1],
arr[k]);//поменяем
текущую строку и строку над ней местами

14           
dec(k);//сдвинемся вверх

15           
end;

16           
end;

17           
end;

2.3.2 Модуль fileIO

Этот модуль
содержит процедуры для файлового ввода/вывода матриц. Используются текстовые
файлы, которые предварительно необходимо открыть и подготовить к чтению/записи.

Формат
файла, содержащего матрицу таков: матрица записана построчно, начиная с первой
строки, элементы в каждой строке записаны слева направо и разделены
произвольным количеством пробелов. Именно такой файл создаёт процедура Write2DArray:

1  
{

2  
записывает
матрицу arr в текстовый файл outFile.
Файл должен быть

3  
предварительно открыт

4  
}

5  
procedure Write2DArray(const arr:
TMatrix; const outFile: TextFile);

6  
var

7  
rowN, colN: integer;

8  
begin

9  
for rowN:= low(arr) to high(arr) do

10           
begin

11           
for colN:= low(arr[rowN]) to
high(arr[rowN]) do

12           
begin

13           
//ширина поля 12, так как -2147483648 - 11
символов

14           
Write(outFile, arr[rowN, colN]: 12);

15           
end;

16           
Writeln(outFile);

17           
end;

18           
end;

Процедура Read2DArray читает файл по строкам, разбирая
каждую строку на подстрока пробелами с помощью процедуры ExtractStrings:

1  
{
читает матрицу arr из текстового
файла inFile. Файл
должен быть

2  
предварительно открыт}

3  
procedure Read2DArray(var arr: TMatrix;
const inFile: TextFile);

4  
var

5  
rowN, colN: integer;

6  
colCount: integer;
//максимальное количество чисел в строке (число столбцов матрицы)

7  
lineStr: string; //текущая строка

8  
strNumbers: TStringList;//текущая
строка, разделённая на подстроки пробелами

9  
begin

10           
rowN:= 0;

11           
colCount:= 0;

12           
strNumbers:= TStringList.Create;

13           
arr:= nil;

14           
while not Eof(inFile) do

15           
begin

16           
Readln(inFile, lineStr);

17           
strNumbers.Clear;

18           
ExtractStrings([' '], [],
PChar(lineStr), strNumbers); //разделим пробелами на подстроки

19           
if colCount < strNumbers.Count then
colCount:= strNumbers.Count;

20           
SetLength(arr, rowN+1,
colCount);//выделим память под новую строку

21           
for colN:= 0 to strNumbers.Count-1 do
//для каждого числа в строке

22           
arr[rowN, colN]:=
StrToIntDef(strNumbers[colN], 0);

23           
Inc(rowN);

24           
end;

25           
strNumbers.Destroy;

26           
end;

2.3.3 Модуль form

Модуль,
содержащий форму, переменную для хранения исходной матрицы, процедуры
синхронизации содержания матрицы и элементов формы, а так же процедуру задания
размеров матрицы.

Так как
задача чётко разделена на задания, оперирующие одними и теми же исходными
данными (целочисленным двумерным массивом), было принято решение разделить
интерфейс приложения на две части. В верхней части формы отображается матрица
исходных данных, которую можно редактировать и размеры которой можно менять.
Нижняя часть формы представляет собой набор закладок, каждая из которых соответствует
одной из поставленных задач. На каждой закладке содержится описание задания,
кнопка «выполнить», а так же элементы, необходимы для отображения результата в
рамках этого задания. Некоторые задания состоят в изменении исходной матрицы,
результат выполнения таких заданий отображается непосредственно в исходных
данных в верхней части формы. Всего существует как минимум три способа выбрать
задачу: щёлкнуть мышкой по закладке, выбрать нужный пункт в меню «Задачи»,
нажать одну из кнопок F1 - F5.

Опишем важные
процедуры формы. Процедура ReadMatrix осуществляет чтение исходных
данных из таблицы на форме в двумерный массив. Перед началом чтения процедура
устанавливает размер массива:

1  
{заполнить
матрицу в соответствии с содержанием таблицы на форме}

2  
procedure TMainForm.ReadMatrix;

3  
var rowN, colN: integer;

4  
begin

5  
SetLength(workMatrix,
G_Matrix.RowCount-1, G_Matrix.ColCount-1);

6  
for rowN:= 0 to G_Matrix.RowCount-2 do

7  
for colN:= 0 to G_Matrix.ColCount-2 do

8  
workMatrix[rowN, colN]:=
StrToIntDef(G_Matrix.Cells[colN+1, rowN+1], 0);

9  
end;

Процедура writeMatrix
осуществляет обратную операцию, она заполняет поля таблицы в соответствии с
массивом. Кроме этого она меняет значения числа строк и столбцов в соответствии
с размерами массива:

1   {заполнить
таблицу на форме в соответствии с содержанием матрицы}

2   procedure
TMainForm.writeMatrix;

3   var
rowN, colN: integer;

4   begin

5   G_Matrix.Cells[1,
1]:= '';//если матрица пуста

6   E_RowsN.Text:=
IntToStr(high(workMatrix) + 1);

7   if(E_RowsN.Text
<> '0') then

8   E_ColsN.Text:=
IntToStr(high(workMatrix[low(workMatrix)]) + 1)

9   else
E_ColsN.Text:= '0';

10           
B_SetDimmsClick(self);

11           
//заполним таблицу

12           
for rowN:= low(workMatrix) to
high(workMatrix) do

13           
for colN:= low(workMatrix[rowN]) to
high(workMatrix[rowN]) do

14           
G_Matrix.Cells[colN+1, rowN+1]:=
IntToStr(workMatrix[rowN, colN]);

15           
end;

Процедура
B_SetDimmsClick является обработчиком нажатия кнопки «задать размеры». Она
проверяет, не стали ли размеры меньше единицы, меняет число строк и столбцов в
таблицах формы, а так же проставляет номера строк и столбцов:

1  
{обраюотчик уствновки размеров матрицы}

2  
procedure
TMainForm.B_SetDimmsClick(Sender: TObject);

3  
var

4  
i: integer;

5  
RowsN, ColsN: integer;

6  
begin

7  
//значения
размеров не должны быть меньше 1

8  
RowsN:= StrToIntDef(E_RowsN.Text, 0);

9  
if RowsN < 1 then begin RowsN:= 1;
E_RowsN.Text:= '1' end;

10           
ColsN:= StrToIntDef(E_ColsN.Text, 0);

11           
if ColsN < 1 then begin ColsN:= 1;
E_ColsN.Text:= '1' end;

12           
//число
строк и столбцов в таблице, учитывая колонку и строку с номерами

13           
G_Matrix.RowCount:= RowsN + 1;

14           
G_Matrix.ColCount:= ColsN + 1;

15           
//в
этих таблицах отображаются одномерные массивы из первого задания

16           
G_Task1B.RowCount:= RowsN;

17           
G_Task1C.RowCount:= RowsN;

18           
//одномерный
массив из четвёртого задания имеет длину, равную числу элементов исходной
матрицы

19           
G_Task4.ColCount:= RowsN * ColsN;

20           
//расставим номера строк и столбцов

21           
for i:= 0 to RowsN do

22           
begin

23           
G_Matrix.Cells[0, i+1]:= IntToStr(i+1);

24           
G_Task1B.Cells[0, i]:= IntToStr(i+1);

25           
G_Task1C.Cells[0, i]:= IntToStr(i+1);

26           
end;

27           
for i:= 0 to ColsN do

28           
G_Matrix.Cells[i+1, 0]:= IntToStr(i+1);

29           
for i:= 0 to RowsN * ColsN do

30           
G_Task4.Cells[i, 0]:= IntToStr(i+1);