Бусыгин Б.С., Коротенко Г.М., Коротенко Л.М. Введение в современную информатику

Подождите немного. Документ загружается.

320

{ == Ввод-вектора А ==}

WriteLn(‘Введите (n) к-во элементов вектора А, которые

будут обрабатываться (не более 50-и)');

ReadLn(n);

WriteLn(‘Введите n элементов вектора А:’);

for i:=1 to n do {Организуем цикл по количеству n элементов}

begin

Write (‘ A[‘,i,’] = ’); {Удобно видеть номера элементов,

которые вводятся}

ReadLn (A[i])

end;

WriteLn; {Устанавливаем курсор на новую строку}

{ == Вывод-вектора А ==}

WriteLn (‘Введённные значения вектора А: ’);

for i:= 1 to n do {Используем оператор Write с форматированием}

Write (‘ А[‘,i,’] = ’,A[i] : 9);{чтобы экономить пр-во экрана}

WriteLn; {Устанавливаем курсор на новую строку}

{== Ввод матрицы В ==}

WriteLn (‘Введите количество элементов матрицы В, которые

обрабатываются – (n,m) (не более 50х50)');

ReadLn(n, m);

WriteLn(‘Введите n × m элементов матрицы В:’);

for i:= 1 to n do { Ввод матрицы В требует }

for j:= 1 to m do { двух циклов с параметром}

begin

Write (‘ B[‘,i,’,’j,’] = ‘);

Read (B[i,j]); {Чтение элемента матрицы}

end;

WriteLn; {Установка курсора после чтения последнего элемента массива}

WriteLn(‘Матрица В с’, n,’ строк и’,m,’ столбцов:’);

for i := 1 to n do { Вывод матрицы В требует }

for j:= 1 to m do { двух циклов с параметром}

Write(‘ B[‘,i,’,’,j,’] = ‘,B[i,j] : 9);

WriteLn; {Устанавливаем курсор на новую строку}

ReadLn

End.

Рис. 8.61. Ввод и вывод массивов на языке Турбо Паскаль (продолжение)

321

8.23.3. Стандартные приёмы работы с векторами и матрицами.

Суммирование элементов массивов

При работе с матрицами, как правило, приходится иметь дело с набором

стандартных приёмов и их композицией. Поэтому Вам необходимо знать

компоненты этого набора, чтобы в будущем конструировать из него фрагменты

алгоритмов программ, которые могут возникнуть из постановки конкретных

задач.

Самой простой из них, является суммирование элементов векторов и

матриц. Для этого в программе необходимо описать переменную Sum такого же

типа, что и элементы массива, и в цикле, по очереди, добавлять к ней элементы

массива:

... {Суммирование элементов одномерного массива – вектора}

⋅

Type

VectorType = Array[1..20] of Real;

Var

A: VectorType;

i, n : Integer; {Параметр цикла и размер вектора}

Sum : Real; {Переменная Sum для суммирования}

⋅

Sum := 0; {Подготовка переменной Sum для суммирования!!!}

for i: =1 to n do

Sum := Sum + A[i];

⋅

Для суммирования элементов двухмерного массива к предыдущему

алгоритму следует добавить ещё один цикл с параметром для обеспечения

перебора всех его индексов:

⋅ ⋅ ⋅

{ Суммирование элементов двухмерного массива}

Type

MatrixType = Array[1..20, 1..25] of Real;

Var

B: MatrixType;

i, j, n, m : Integer; {Параметры циклов и границы массива}

Sum : Real; {Переменная Sum для суммирования элементов}

⋅ ⋅ ⋅

Sum := 0; {Подготовка переменной Sum для суммирования}

for i:= 1 to n do {Двигаемся вдоль строки}

for j:= 1 to m do {Двигаемся по столбцу}

Sum := Sum + B[i, j];{Суммируем в Sum каждый элемент

матрицы}

{Для вычисления среднего арифметического добавляем оператор}

Sum := Sum / (n*m);}

⋅ ⋅ ⋅

322

8.23.4. Использование счётчика

Ещё одной распространённой задачей, является подсчёт элементов матриц

с определёнными характеристиками, к примеру, положительных или

отрицательных элементов. Это требует введение в тело цикла условного

оператора:

⋅ ⋅ ⋅

{Определим количество положительных элементов Count типа Integer}

Count := 0; {Подготовка переменной Count для суммирования!!!}

for i:= 1 to n do

if A[i] > 0 then{Определение полодительного элемента}

Count := Count + 1;{Увеличение количества положительных элементов}

⋅ ⋅ ⋅

Теперь у Вас не возникнет трудностей при составлении алгоритма для

определения положительных элементов двухмерного массива, то есть матрицы.

Кроме этого, теперь Вы можете использовать этот алгоритм для определения:

1. числа отрицательных или нулевых элементов;

2. числа элементов, равных заданному числу;

3. числа элементов массива, содержащих числа превышающие или не

превышающие заранее заданное число;

4. числа элементов, содержащих значения, находящиеся в заданном

интервале и т.д.

Теперь давайте используем наши знания для конструирования алгоритма

нахождения среднего арифметического положительных элементов двухмерного

массива. Для этого необходимо вычислить сумму положительных элементов

матрицы и их количество, то есть применить одновременно уже известные нам

алгоритмы суммирования и «счётчика»:

⋅ ⋅ ⋅

{Композиция: «суммирование» + «счётчик»}

{Находим середнее арифметическое положительных элементов }

Type

MatrixType = Array[1..20, 1..25] of Real;

Var

B: MatrixType;

i, j, n, m : Integer; {Параметры циклов и границы массива}

Sum : Real; {Переменная Sum для суммирования}

⋅ ⋅ ⋅

Sum := 0; {Обнуление переменной Sum для суммирования}

Count := 0;

for i:= 1 to n do

for j:= 1 to m do

if B[i,j] > 0

then begin

Sum := Sum + B[i,j];

Count := Count +1;

end;

Sum := Sum/ Count; {Среднее арифм. положительных элементов }

⋅ ⋅ ⋅

323

8.23.5. Определение max/min элемента массива

Очень часто программирование алгоритмов работы с матрицами требует

определения максимального или минимального элемента. Для этого существует

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

⋅ ⋅ ⋅

Max := A[1]; {Считаем, что первый элемент массива – максимальный }

for i:= 2 to n do {Поэтому начинаем обработку со второго элемента}

if A[i] > Max {Сравниваем каждый следующий элемент с текущим

максимальным значением }

then Max:= A[i];{Заменяем старое значение Max новым бŏльшим }

{После выполнения цикла в Max находится максимальное значение из A }

⋅ ⋅ ⋅

На базе этого алгоритма можем сконструировать алгоритм определения

минимального элемента двухмерного массива и его индексов:

⋅ ⋅ ⋅

Var

IndI, IndJ : Integer; {Переменные для сохранения индексов}

⋅ ⋅ ⋅

Min := B[1,1];

for i:= 1 to n do

for j:= 1 to m do

if B[i,j] < Min

then begin

Min := B[i,j];

IndI := i;

Indj := j

end;

⋅ ⋅ ⋅

8.23.6 Работа с чётными и нечётными элементами массива

Ещё одним достаточно полезным алгоритмом, который может Вам

понадобиться при работе с массивами, является поиск чётных/нечётных

элементов целых массивов и их суммирование. Для этого в Турбо Паскале

существует специальная встроенная логическая функция Odd(x), которая при

целом аргументе x возвращает значение True, если x нечётное число, и False

в случае чётного числа:

⋅ ⋅ ⋅

{Находим сумму нечётных элементов с использованием функции Odd(i)}

Sum := 0;

for i:=1 to n do

if Odd(i) then {для чётных – условие – not Odd(i)}

Sum := Sum + A[i];

⋅ ⋅ ⋅

324

8.23.7. Решение практической задачи с массивами

Тепер, когда Вы уже владеете основными приёмами работы с матрицами,

попробуем решить конкретную задачу в соответствии со сформулированной в

п.8.1 технологии работы в среде ТП. Например, рассмотрим такую задачу.

Даны два трёхмерных вектора













321

,, xxxX













321

,, yyyY

Требуется найти угол между ними.

1. На первом шаге, Вам необходимо решить задачу в её предметной

области, то есть привести её к виду, когда Вы можете представить себе все

действия по созданию алгоритма решения задачи. Как следует из справочника

по математике

, эта задача относится к области векторного счисления, из

раздела "Геометрические приложения векторной алгебры", где приведена

формула вычисления угла между трёхмерными векторами

cos

(8.15)

–где

zzyyxx

yxyxyxYX ++=

– скалярное произведение векторов

;

– длина вектора

2222

zyx

xxxXX ++==

;

(8.16)

– длина вектора

С учётом этих зависимостей, конечная формула примет вид (8.17):

222222

cos

zyxzyx

zzyyxx

yyyxxx

yxyxyx

++++

(8.17)

Таким образом, мы получили конечное, формульное выражение искомой

величины, вполне пригодное для программирования на языке Турбо Паскаль.

Вычисление самого значения φ рассмотрено далее в п.8.24.

2. Далее, на втором шаге, Вы должны выбрать входные и выходные

данные для программного компонента. Для нашей задачи входными данными

будут значения компонентов, составляющих векторы

YиX

: x

, x

и y

, y

. Выходными данными будет значение

cos

(т.е. косинуса угла между ними).

3. Проходим по разделам описаний программы. Из стандартных библиотек

для работы программы, очевидно, понадобится модуль Crt для использования

из него процедуры очистки экрана ClrScr.

4. На четвёртом шаге выбираем структуры данных. Для нашей задачи они

могут выглядеть следующим образом:

Бронштейн И.Н., Семендяев К.А. Справочник по математике для инженеров и учащихся втузов. – М.: Наука,

Гл. ред. физ.-мат. лит., 1968. – 544 с.

325

Const

n = 3;

Type

VectorType = Array[1..n] of Real;

Var

X, Y : VectorType; {Массивы для векторов}

XY, {Переменная для значения скалярного произведения}

SumX, {Переменная для суммирования квадратов компонентов

}

SumY, {Переменная для суммирования квадратов компонентов

}

CosFi : Real; {Переменная для вычисления результата}

i : Integer; {Переменная-параметр цикла}

Так, как Вы уже имеете некоторый опыт в программировании, то можете

предвидеть, что в алгоритме понадобится отдельно суммировать скалярное

произведение в числителе формулы (8.17), и суммы квадратов компонентов

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

5. Разработка интерфейса программы не представляется сложной задачей.

Ввод элементов векторов был уже рассмотрен в разделе 8.23.2, а вывод

результата и вовсе простой.

6. Для работы с массивами нам понадобится управляющая структура for,

в теле которой мы и разместим все вычисления с векторами.

7. На данном этапе Вы должны собрать все разработанные элементы в

единое целое, что и будет в конечном итоге программой вычисления (рис. 8.62):

Program VectorAngle;

Uses

Crt;

Const

n = 3;

Type

VectorType = Array[1..n] of Real;

Var

X, Y : VectorType; XY, SumX, SumY, CosFi : Real;

i : Integer;

Begin

ClrScr;

{Здесь должен располагаться алгоритм заполнения данными массивов X и Y}

XY := 0;

SumX := 0;

SumY := 0;

for i:=1 to n do

begin

XY := XY + X[i]*Y[i];

SumX := SumX + X[i];

SumY := SumY + Y[i];

end;

CosFi := XY / (sqrt(SumX)*sqrt(SumY));

WriteLn('CosFi = ', CosFi); ReadLn

End.

Рис. 8.62. Вычисление угла между двумя трёхмерными векторами

326

Упражнения

1. Даны два трёхмерных вектора

( )

xxxX

...

( )

yyyY

...

Найти угол между ними при произвольных числовых значениях компонентов

векторов.

2. В массиве D=(

12,21

...,,

ddd

) определить среднее арифметическое S

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

3. В вещественном массиве D=(

12,21

...,,

ddd

) определить произведение P

положительных элементов, количество K нулевых элементов и сумму S

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

4. В целом массиве B=(

10,21

...,,

bbb

) определить максимальный элемент M

и значение его индекса. Максимальный элемент заменить на значение “0”.

5. Дана вещественная матрица Q(3,6). Определить значения минимального

и максимального элементов матрицы, значения их индексов в массиве и их

произведение.

6. Дана матрица A(4,6). Определить сумму S элементов, которые

превышают по модулю единицу в каждом чётном столбце и количество таких

элементов.

7. Дана матрица X(6,6). Определить максимальный элемент на главной

диагонали и сумму елементов главной диагонали.

8. Дана матрица C(7,7). Определить произведение положительных

элементов матрицы, расположенных на пересечении чётных строк и нечётных

столбцов.

327

8.24. Модули и работа с ними

При составлении предыдущих алгоритмов мы уже неоднократно

использовали в своих программах так называемые модули (вспомните

подключение библиотечного модуля Турбо Паскаля Crt для вызова из него

процедуры очистки экрана ClrScr). Все системные библиотеки Турбо Паскаля

реализованы в виде модулей, и чтобы использовать их мы должны поместить в

программе строку описания:

Uses Crt, Graph; {Или имена других необходимых модулей}

Вообще модули предназначены для поддержки принципов модульного

программирования при разработке программ. В соответствии с этим принципом

взаимное влияние логически независимых фрагментов программы должно быть

сведено к минимуму. Однако важнейшими полезными свойствами модулей

явялется возможность сохранять в них оформленные в виде процедур и

функций алгоритмы, которые Вы разрабатываете в течение Вашей работы и

желаете повторно использовать. Кроме этого, Ваша программа, в которой

описаны модули, “видит” все данные модулей (а также описания типов

констант и переменных). Поэтому, при необходимости их использования, нет

необходимости описывать все эти характеристики в основной программе.

Как правило, модуль разделяется на четыре части:

1. Заголовок модуля (Unit Name;)

2. Раздел объявлений или интерфейс (Interface)

3. Раздел реализации (Implementation)

4. Раздел инициализации (между Begin и End)

Все блоки, составляющие эти разделы, являются необязательными и

могут или отсутствовать, или появляться неоднократно. Наименьший по своим

размерам, бесплодный, но правильный с точки зрения языка ТП модуль имеет

вид:

Unit Empty;

Interface

Implementation

End.

Обратите внимание, что символы точка с запятой после ключевых слов

отсутствуют. Если отсутствует раздел инициализации, то служебное слово

Begin не ставится.

В принципе, структура полезного модуля подобна структуре паскаль-

программы:

Unit UnitName; {Заголовок модуля. Рекомендуется длина имени

UnitName <= 8 символов}

Interface {Раздел объявлений, которые будут использоваться в этом

модуле и в программах, которые его будут использовать!}

Uses ...; {Список модулей, вызываемых из данного модуля}

Const ...; {Объявления библиотечных констант}

328

Type ...; {Блок объявлений библиотечных типов}

Var ...; {Блок объявлений библиотечных переменных}

Procedure ProcName(FormalParametersList); {В этом

разделе записываются только заголовки процедур с

формальными параметрами!}

Function FuncName(FormalParametersList):Type; {В этом

разделе записываются только заголовки функций с

формальными параметрами!}

Implementation {Раздел реализации}

Uses ...; {Используются при реализации модулей}

Const ...; { Описания в разделе Implementation }

Type ...; { “видят” только этот }

Var ...; { модуль }

Procedure ProcName; {В этом разделе записываются только

заголовки процедур без формальных параметров и их тела!}

Function FuncName; {В этом разделе записываются только

заголовки функций без формальных параметров и их тела!}

Begin

{Блок инициализации модуля}

End.

Обратите внимание на то, что точки с запятой после ключевых слов

отсутствуют. Если нет раздела инициализации, то Begin тоже не ставится.

В принципе, структура полезного модуля похожа на паскаль-программу:

Unit UnitName; {Заголовок модуля. Рекомендуемая длина имени

UnitName <= 8 символов}

Interface {Раздел объявлений, которые будут использоваться в этом

модуле и в программах, вызывающих его!}

Uses ...; {Список модулей, используемых в этом модуле}

Const ...; {Объявления библиотечных констант}

Type ...; {Блок объявлений библиотечных типов}

Var ...; {Блок объявлений библиотечных переменных}

Procedure ProcName(FormalParametersList);{В этом разделе

записываются только заголовки процедур с формальными

параметрами!}

Function FuncName(FormalParametersList):Type; {В этом

разделе записываются только заголовки функций с

формальными параметрами!}

Implementation {Раздел реализации}

Uses ...; {Используемые при реализации модули}

Const ...; { Описания в розделе Implementation }

329

Type ...; { Описания, которые “видит” }

Var ...; { только этот модуль }

Procedure ProcName; {В этом разделе записываются только

заголовки процедур без формальных параметров и их тела!}

Function FuncName; {В этом разделе записываются только

заголовки функций без формальных параметров и их тела!}

Begin

{Блок инициализации модуля}

End.

Тепер мы можем выполнить упражнение 1 из раздела 8.23.7 с

использованием модуля. Приведём его условие.

Упражнение 8.23.7.1: Даны два вектора

( )

xxxX

...

( )

yyyY

...

Найти угол между ними.

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

в трёхмерном пространстве, можно реализовать стандартный, т.е.

общеупотребительный модуль, который будет содержаться в библиотеке

модулей и вызываться по мере необходимости. Данный модуль может

содержать описания необходимых структур данных, процедуру ввода

компонентов векторов с наперёд заданным их количеством и функцию

вычисления угла между двумя векторами с n компонентами. В п. 8.23.7

приведена формула вычисления cos φ. Учитывая тот факт, что все встроенные

тригонометрические функции ТП работают с аргументами в радианах, значение

φ может вычисляться в зависимости от конкретной задачи следующим образом:

y = cos φ

рад

; φ

рад

= arccos(y) = π/2 – arctg(y/(1-y

)

0.5

); φ

град

= φ

рад

180º/ π.

К примеру, y = cos π/3 = cos (1.047198) = cos 60º = 0.5;

рад

= arccos(0.5) = π/2 – arctg(y/(1-y

)

0.5

)=1.047198;

град

= 1.047198

180º/ π=60º (где π = 3.141593).

Текст модуля MyUnit приведен на рисунке 8.63.

Unit MyUnit;

Interface

Uses

Crt; {В этом модуле используем библиотечный модуль Crt}

Type

VectorType = Array[1..50] of Real;

Var

XX, YY : VectorType; {Массивы, которые используются в

модуле,}

{а также в программе, где он описан}

j : Integer;

Рис. 8.63. Структура модуля, для вычисления углов между векторами