s
Sesiya.ru

Создание пользовательских модулей в Pascal

Информация о работе

Тема
Создание пользовательских модулей в Pascal
Тип Курсовая работа
Предмет Программирование
Количество страниц 44
Язык работы Русский язык
Дата загрузки 2014-12-21 15:53:57
Размер файла 47.62 кб
Количество скачиваний 64
Скидка 15%

Поможем подготовить работу любой сложности

Заполнение заявки не обязывает Вас к заказу


Скачать файл с работой

Помогла работа? Поделись ссылкой

МИНОБРНАУКИ РОССИИ

Орский гуманитарно-технологический институт (филиал)
федерального государственного бюджетного образовательного учреждения
высшего профессионального образования
«Оренбургский государственный университет»


Физико-математический факультет
Кафедра математики, информатики, теории и методики обучения информатике




КУРСОВАЯ РАБОТА
по дисциплине "Программирование"


Создание пользовательских модулей в Pascal





Руководитель работы
___________________ А.С. Попов
"_____"_________________ 2014 г.
Исполнитель
Студент гр10Ин
___________________ С. К.Миндалинова
"_____"_________________ 2014 г.



Орск 2014




МИНОБРНАУКИ РОССИИ
ОГУ

Орский гуманитарно-технологический институт (филиал) ОГУ

Физико-математический факультет
Кафедра математического анализа, информатики, теории и методики обучения информатике


Задание на курсовую работу

Создание пользовательских модулей в Pascal

Исходные данные: Законодательные и нормативно-правовые акты
Минобрнауки РФ, ФГОС ООО, научно-методические
работы отечественных авторов, научная и
учебно-методическая литература по исследуемой проблеме
Перечень подлежащих разработке вопросов:
а) проанализировать учебно-методическую литературу по проблеме исследования;
б) рассмотреть среду программирования Pascal и ее структуру;
в) изучить модули в Pascal;
г) разработать лабораторные работы по теме «Создание пользовательских модулей в Pascal»;


Дата выдачи задания “___”______________20__ г.


Руководитель
Старший преподаватель
А.С. Попов

Исполнитель
студент группы 10Ин
С.К. Миндалинова

Срок защиты работы “___”______________20__ г.




Содержание
Введение…...............................................................................................................4
1 Модули в Pascal……………..………………………...……...............................6
1.1 Структура модулей………………………………………..............................10
1.2 Заголовок модулей и связь модулей друг с другом……….………………12
1.3 Интерфейсная часть…………………………………………………………13
1.4 Исполняемая часть………………………………………...…………….......14
1.5 Инициирующая часть………………………....……………………………..16
1.6 Компиляция модулей…………………………………..................................17
1.7 Доступ к объявленным в модуле объектам……………...............................20
2 Комплекс лабораторных работ по созданию пользовательских модулей в Паскаль
2.1 Лабораторная работа № 1 «Написание программы на языке Паскаль с использованием разработанного собственного модуля»……………………...23
2.2 Лабораторная работа № 2 «Разработка модулей. Turbo Pascal»…………33
Заключение…………………………………………………………….…………39
Список используемых источников……………………………………………..40
Приложение 1…………………………………………………………………….42












Введение
В 1992 году фирма Borland International выпустила два пакета программирования на использовании языка Паскаль, - Borland Pascal 7.0 и Turbo Pascal 7.0.
Пакет Borland Pascal 7.0 учитывает многие новейшие достижения в программировании и практике создания программ и включает в себя три режима работы: в обычном режиме операционной системы MS DOS, в защищенном режиме MS DOS и в среде Windows. Обладая расширенными возможностями, пакет Borland Pascal 7.0 тем не менее требует для использования всех своих возможностей довольно большую память – примерно 30 Мбайт на жестком диске и не менее 2 Мбайт оперативной памяти.
Пакет Turbo Pascal 7.0 обладает ограниченными возможностями и позволяет работать только в обычном режиме MS DOS. Начинающему программисту, по-видимому, целесообразно начать изучение языка и среды именно с этого пакета.
Язык характеризуется расширенными возможностями по сравнению со стандартом, хорошо развитой библиотекой модулей, позволяющих использовать возможности операционной системы, создавать оверлейные структуры, организовывать ввод-вывод, формировать графическое изображение и т.д.
Среда программирования позволяет создавать тексты программ, компилировать их, находить ошибки и оперативно их исправлять, компоновать программы из отдельных частей, включая стандартные модули, отлаживать и выполнять отлаженную программу.
В данной работе будут описаны основные возможности языка, работа в интегрированной среде, набор стандартных модулей.
Объектом исследования – «модули в Pascal».
Предметом исследования – среда программирования Turbo Pascal.
Цель данной работы разработать комплекс лабораторных работ по теме «Создание пользовательских модулей в Pascal».
Для достижения поставленной цели необходимо решить следующие задачи:
 проанализировать учебно-методическую литературу по проблеме исследования;
 рассмотреть среду программирования Pascal и ее структуру;
 изучить модули в Pascal;
 разработать лабораторные работы по теме «Создание пользовательских модулей в Pascal».

1 Модули в Pascal
Модуль  это автономно компилируемая программная единица, включающая в себя различные компоненты раздела описаний (типы, константы, переменные, процедуры и функции) и, возможно, некоторые исполняемые операторы инициирующей части.
Модули можно разделить на стандартные, которые входят в состав системы программирования, и пользовательские, то есть создаваемые программистом. Чтобы подключить модуль к программе, его требуется предварительно скомпилировать. Результат компиляции каждого модуля хранится на диске в отдельном файле с расширением .tpu.
Стандартные модули
В Турбо Паскале имеется восемь стандартных модулей, в которых содержится большое число разнообразных типов, констант, процедур и функций. Этими модулями являются SYSTEM, DOS, CRT, PRINTER, GRAPH, OVERLAY, TURBO3 и GRAPHS. Модули GRAPH, TURBOS и GRAPHS содержатся в одноименных ТPU-файлах, остальные входят в состав библиотечного файла TURBO.TPL. Лишь один модуль SYSTEM подключается к любой программе автоматически, все остальные становятся доступны только после указания их имен в списке, следующем за словом USES. Ниже приводится краткая характеристика стандартных модулей. Модуль SYSTEM  в него входят все процедуры и функции стандартного Паскаля, а также встроенные процедуры и функции Турбо Паскаля, которые не вошли в другие стандартные модули (например, INC, DEC, GETDIR и т.п.). Как уже отмечалось, модуль SYSTEM подключается к любой программе независимо от того, объявлен ли он в предложении USES или нет, поэтому его глобальные константы, переменные и подпрограммы считаются встроенными в Турбо Паскаль. Модуль PRINTER делает доступным вывод текстов на матричный принтер. В нем определяется файловая переменная LST типа TEXT, которая связывается с логическим устройством PRN. После подключения модуля может быть выполнена, например, такая программа:
Uses Printer;
begin
WriteLn (LST, Турбо Паскаль);
end.
Модуль CRT. В нем сосредоточены процедуры и функции, обеспечивающие управление текстовым режимом работы экрана. С помощью входящих в модуль программ можно перемещать курсор в произвольную позицию экрана, менять цвет выводимых символов и окружающего их фона, создавать окна. Кроме того, в модуль включены также процедуры «слепого» чтения клавиатуры и управления звуком. Модуль GRAPH содержит обширный набор типов, констант, процедур и функций для управления графическим режимом работы экрана. С помощью подпрограмм, входящих в модуль GRAPH, можно создавать разнообразные графические изображения и выводить на экран текстовые надписи стандартными или разработанными программистом шрифтами. Подпрограммы модуля GRAPH после соответствующей настройки могут поддерживать различные типы аппаратных графических средств. Настройка на имеющиеся в распоряжении программиста технические средства графики осуществляется специальными программами - драйверами, которые не входят в библиотечный файл GRAPH.TPU, но поставляются вместе с ним. Модуль DOS. В модуле собраны процедуры и функции, открывающие доступ программам к средствам дисковой операционной системы MS DOS. Модуль OVERLAY. Он необходим при разработке громоздких программ с перекрытиями. Как уже говорилось, Турбо Паскаль обеспечивает создание программ, длина которых ограничивается лишь доступной оперативной памятью ПК. Для большинства IBM-совместимых ПК доступная программе память составляет около 580 Кбайт (без инструментальных оболочек типа Norton Commander и без самой системы Турбо Паскаль). Память такого размера достаточна для большинства применений, тем не менее, использование программ с перекрытиями снимает это ограничение. Два библиотечных модуля TURBO3 и GRAPH3 введены для совместимости с ранней версией 3.0 системы Турбо Паскаль.
Наличие модулей в Turbo Pascal позволяет программировать и отлаживать программу по частям, создавать библиотеки подпрограмм и данных, воспользоваться возможностями стандартных модулей, практически неограниченно увеличивать кодовую (содержащую коды команд) часть программы.
Модуль содержит описания типов данных, переменных и других объектов, а также подпрограммы, которые используются в различных программах. Подпрограмму имеет смысл включать в состав модуля в том случае, когда она реализует действие, которое приходится выполнять достаточно часто. Подпрограммы, входящие в модуль, можно написать, отладить и откомпилировать один раз, а использовать многократно.
Модули представляют собой прекрасный инструмент для разработки библиотек прикладных программ и мощное средство модульного программирования. Важная особенность модулей заключается в том, что компилятор Турбо Паскаля размещает их программный код в отдельном сегменте памяти. Максимальная длина сегмента не может превышать 64 Кбайта, однако количество одновременно используемых модулей ограничивается лишь доступной памятью, что дает возможность создавать весьма крупные программы.
Доступ к описаниям, функциям и процедурам модуля обеспечивает оператор использования Uses, в котором указывается имя модуля. Этот оператор размещается в разделе описаний программы, сразу после заголовка. Если в программе используется не один модуль, а несколько, необходимо указать имена всех модулей, перечислив их через запятую. Исключением является модуль System, ссылка на который необязательна. Этот модуль содержит, в частности, процедуры файлового ввода/вывода, процедуры и функции для работы со строками и некоторые другие.
Модуль начинается заголовком
unit unit_name;
где unit_name – имя модуля, которое выбирается в соответствии с правилами Паскаля. Файл, содержащий модуль, обязан иметь то же имя, что и модуль.
Разберем в качестве примера модуль с описанием гиперболических функций, которых нет в числе встроенных функций языка Паскаль, но эти функции достаточно часто появляются в прикладных задачах, и поэтому имеет смысл включить их в состав библиотечного модуля. Доступ к функциям из этого модуля обеспечивает оператор использования Uses, в котором указывается имя модуля. Итак, сам модуль выглядит следующим образом.
{$N+}
unit hyp_fun;
interface
type
Float = Extended;
function sinh(x: Float): Float;
function cosh(x: Float): Float;
function tanh(x: float): Float;
implementation
var
t: Float;
function sinh(x: Float): Float;
begin
t := Exp(x);
sinh := 0.5*(t – 1.0/t);
end;
function cosh(x: Float): Float;
begin
t := Exp(x);
cosh := 0.5*(t + 1.0/t);
end;
function tanh(x: Float): Float;
begin
t := Exp(2.0*x);
tanh := (t – 1.0) / (t + 1.0);
end;
end.
Зарезервированные слова interface и implementation здесь играют важную роль. Каждый модуль имеет части (секции), озаглавленные этими словами. Секция interface (она называется интерфейсной секцией) содержит описания констант, типов, переменных и процедур, доступных из вызывающей программы или модуля. Секция implementation (секция реализации) содержит исходный код программы. Она может также содержать локальные описания, такие как var t: Real; из нашего примера.
Каждый модуль начинается с зарезервированного слова unit и заканчивается словом end, за котором следует точка. Для этого end не требуется соответствующего слова begin, хотя можно и поставить его непосредственно перед end. Оператор type в начале нашего модуля определяет тип Float, который в данном случае эквивалентен типу Extended. Указав, справа от знака равенства любой другой эквивалентный тип, можно изменить точность вычисления гиперболических функций.

1.1 Структура модулей
Модуль имеет следующую структуру:
Unit < имя_модуля >;
interface < интерфейсная часть >;
implementation < исполняемая часть >;
begin
< инициирующая часть >;
end .
Здесь Unit  зарезервированное слово (единица), начинает заголовок модуля; name  имя модуля (правильный идентификатор); Interface – интерфейсная секция – содержит те описания типов, переменных и других объектов данных, которые можно использовать в других программах или модулях; секция реализации начинается с зарезервированного слова implementation. Все описания, содержащиеся в секции реализации, являются локальными, их область действия – данный модуль. Здесь же содержаться полные описания функций и процедур модуля. Последняя часть модуля – секция инициализации. Она может быть пустой и содержать только зарезервированное слово end или включать в себя исполняемые операторы, выполняющие необходимые действия по инициализации (например, по присваиванию начальных значений переменным) модуля.
В качестве примера рассмотрим модуль func1 (см. приложение 1), расширяющий вычислительные возможности Турбо Паскаля, так как он содержит функции, отсутствующие в стандартных модулях системы. Среди «стандартных» функций – синус (Sin), косинус (Cos), арктангенс (ArcTan), экспонента (Exp), натуральный логарифм (Ln), квадрат числа (Sqr) и квадратный корень из него (Sqrt). В модуле func1 имеются тангенс (Tan), арксинус (ArcSin) и арккосинус (ArcCos), функции перевода градусной меры в радианную и наоборот (Degrees_to_Radians, Radians_to_Degrees), набор гиперболических функций (Sinh, Cosh, Tanh), а также десятичный логарифм (Log10) и произвольная степень числа (Power).
Напомним математическое определение гиперболических функций:



В нашем примере интерфейсная секция содержит описания вещественного типа float, а также константу Infinity – «бесконечно большое значение». Бесконечность здесь понимается, разумеется, в смысл машинной арифметики, как значение, близкое к максимально допустимому для типа Extended. Далее следуют заголовки функций модуля.
Секция реализации содержит константы, используемые в подпрограммах-функциях. Затем идут полные описания функций. Вычисление тангенса использует «классическое» определение этой функции как отношение синуса к косинусу. Учтено также приближение значения тангенса к бесконечности при определенных значениях аргумента. В этом случае функция возвращает «машинную бесконечность».
При программировании арксинуса и арккосинуса следует учитывать то, что эти функции – многозначные. В нашем случае вычисляется «главное значение», лежащее в интервале [-/2, /2] (для арксинуса) или [0, ] (для арккосинуса) радиан. Для этого используются формулы, известные из курса элементарной математики.
При вычислении гиперболических функций учитывается то обстоятельство, что уже при относительно небольших значениях аргумента вычисление экспоненты приводит к арифметическому переполнению. В этом случае функция возвращает «бесконечное» значение.

1.2 Заголовок модуля и связь модулей друг с другом
Заголовок модуля состоит из зарезервированного слова Unit  следующего за ним имени модуля. Для правильной работы среды Турбо Паскаля и возможности подключения средств, облегчающих разработку крупных программ, это имя должно совпадать с именем дискового файла, в который помещается исходный текст модуля. Если, например, имеем заголовок
Unit Global;
то исходный текст соответствующего модуля должен размещаться в дисковом файле GLOBAL.PAS. Имя модуля служит для его связи с другими модулями и основной программой. Эта связь устанавливается специальным предложением
Uses <сп.модулей>
Здесь Uses - зарезервированное слово (использует);
<сп.модулей> - список модулей, с которыми устанавливается связь;
элементами списка являются имена модулей, отделяемые друг от друга
запятыми, например:
Uses CRT, Graph, Global:
Если объявление Uses... используется, оно должно открывать раздел описаний основной программы. Модули могут использовать другие - модули. Предложение Uses в модулях может следовать либо сразу за зарезервированным словом Interface, либо сразу за словом Implementation.

1.3 Интерфейсная часть
Через интерфейс осуществляется взаимодействие основной программы с модулем (модуля с модулем). В интерфейсе указываются константы, типы, переменные, процедуры и функции, которые могут быть использованы основной программой (модулем) при вызове этого модуля.
Интерфейсная часть открывается зарезервированным словом Interface. В этой части содержатся объявления всех глобальных объектов модуля (типов, констант, переменных и подпрограмм), которые должны стать доступными основной программе и/или другим модулям. При объявлении глобальных подпрограмм в интерфейсной части указывается только их заголовок, например:
Unit Cmplx;
Interface
type
complex = record
re, Im : real
end;
Procedure AddC (x, у : complex; var z : complex);
Procedure MulC (x, у : complex; var z : complex);
Если теперь в основной программе написать предложение
Uses Cmplx;
то в программе станут доступными тип Complex и две процедуры  AddC и МulC из модуля Cmplx.
Отметим, что объявление подпрограмм в интерфейсной части автоматически сопровождается их компиляцией с использованием дальней; модели памяти. Таким образом, обеспечивается доступ к подпрограммам из основной программы и других модулей.
Следует учесть, что все константы и переменные, объявленные интерфейсной части модуля, равно как и глобальные константы и переменные основной программы, помещаются компилятором Турбо Паскаля в общий сегмент данных (максимальная длина сегмента 65536 байт). Порядок появления различных разделов объявлений и их количество может быть произвольным. Если в интерфейсной части объявляются внешние подпрограммы или подпрограммы в машинных кодах, их тела (т.е. зарезервированное слово External, в первом случае, и машинные коды вместе со словом Inline  во втором) должны следовать сразу за их заголовками в исполняемой части модуля (не в интерфейсной). В интерфейсной части модулей нельзя использовать опережающее описание.
В интерфейсах различных модулей недопустимо циклическое обращение друг к другу, т.к. компилятор в этом случае не может установить связей.

1.4 Исполняемая часть
Исполняемая часть включает все подпрограммы модуля. Она может также включать локальные метки, константы, типы и переменные.
Исполняемая часть начинается зарезервированным словом Implementation и содержит описания подпрограмм, объявленных в интерфейсной части. В ней могут объявляться локальные для модуля объекты - вспомогательные типы, константы, переменные и блоки, а также  метки, если они используются в инициирующей части.
Описанию подпрограммы, объявленной в интерфейсной части модуля, в исполняемой части должен предшествовать заголовок, в котором можно опускать список формальных переменных (и тип результата для функции), так как они уже описаны в интерфейсной части. Но если заголовок подпрограммы приводится в полном виде, т.е. со списком формальных параметров и объявлением результата, он должен совпадать с заголовком, объявленным в интерфейсной части, например:
Unit Cmplx;
Interface
type
complex = record;
re, im: Real;
end;
Procedure AddC (x, у : complex; var r : complex);
Implementation
Procedure AddC;
begin
z.re := x.re + y.re;
z,im := x.Im * y.im;
end;
end.
Локальные переменные и константы, а также все программные коды, порожденные при компиляции модуля, помещаются в общий сегмент памяти.
В отличие от интерфейсов модулей в исполнительных частях модулей допустимо циклическое обращение друг к другу, т.к. все равно взаимодействие осуществляется через интерфейсы, и здесь не возникает проблемы с установлением необходимых связей.

1.5 Инициирующая часть
В некоторых случаях перед обращением к модулю следует провести его инициализацию (например, установить связь с теми или иными файлами с помощью процедуры Assign, инициализировать какие-то переменные и т.д.). Необходимые действия можно выполнить в секции инициализации модуля. Эта секция начинается словом begin, после которого идут исполняемые операторы, а затем помещается слово end. (с точкой), например:
begin
Assign (F1, ‘ FILE1.DAT ‘);
end.
В инициирующей части размещаются исполняемые операторы, содержащие некоторый фрагмент программы. Эти операторы исполняются до передачи управления основной программе и обычно используются для подготовки ее работы. Например, в них могут инициироваться переменные, открываться нужные файлы, устанавливаться связи с другими ПК по коммуникационным каналам и т.п.:
Unit FileText;
Interface
Procedure Prlnt (t : string);
Implementation
var f: Text;
const
name = OUTPUT. TXT ;
Procedure Print;
begin
WriteLn (f, s);
end;
{Начало инициирующей части:}
begin
Assign (f, name);
Rewrite (f);
{Конец инициирующей части:}
end.
Следует иметь в виду, что операторы секции инициализации выполняются единственный раз в момент запуска программы.
Если инициализация модуля не нужна, то в секции помещается лишь слово end.

1.6 Компиляция модулей
В среде Турбо Паскаля имеются средства, управляющие способом компиляции модулей и облегчающие разработку крупных программных проектов. В частности, определены три режима компиляции: COMPILE, МАКЕ и BUILD. Режимы отличаются только способом связи, компилируемого модуля или основной программы с другими модулями, объявленными в предложении USES.
При компиляции модуля или основной программы в режиме COMPILE все упоминающиеся в предложении USES модули должны быть предварительно откомпилированы, и результаты компиляции помещены в одноименные файлы с расширением .TPU (Turbo Pascal Unit - Модуль Турбо Паскаля). Например, если в программе (модуле) имеется предложение
Uses Global;
то на диске в каталоге, объявленном опцией UNIT DIRECTORIES, уже должен находиться файл GLOBAL.TPU. Файл с расширением TPU (от англ. Turbo Pascal Unit) создается в результате компиляции модуля.
В режиме МАКЕ компилятор проверяет наличие TPU-файлов для каждого объявленного модуля. Если какой-либо из файлов не обнаружен, система пытается отыскать одноименный файл с расширением .PAS, т.е. файл с исходным текстом модуля, и, если .PAS-файл найден, приступает к его компиляции. Кроме того, в этом режиме система следит за возможными изменениями исходного текста любого используемого модуля. Если в PAS-файл (исходный текст модуля) внесены какие-либо изменения, то независимо от того, есть ли уже в каталоге соответствующий TPU-файл или нет, система осуществляет его компиляцию перед компиляцией основной программы. Более того, если изменения внесены в интерфейсную часть модуля, то будут перекомпилированы также и все другие модули, обращающиеся к нему. Режим МАКЕ, таким образом, существенно облегчает процесс разработки крупных программ с множеством модулей: программист избавляется от необходимости следить за соответствием существующих TPU-файлов их исходному тексту, так как система делает это автоматически.
В режиме BUILD существующие TPU-файлы игнорируются, и система пытается отыскать (и компилировать) соответствующий PAS-файл для каждого объявленного в предложении USES модуля. После компиляции в режиме BUILD программист может быть уверен в том, что учтены все сделанные им изменения в любом из модулей.
Подключение модулей к основной программе и их возможная компиляция осуществляются в порядке их объявления в предложении USES. При переходе к очередному модулю система предварительно отыскивает все модули, на которые он ссылается. Ссылки модулей друг на друга могут образовывать древовидную структуру любой сложности, однако запрещается явное или косвенное обращение модуля к самому себе. Например, недопустимы следующие объявления:
Unit A; Unit B;
Interface Interface
Uses S; Uses A;
Implementation Implementation
end.
end.
Это ограничение можно обойти, если «спрятать» предложение USES в исполняемые части зависимых модулей:
Unit A; Unit B;
Interface Interface
Implementation Implementation
Uses B; Uses A;
end.
end.
Дело в том, что Турбо Паскаль разрешает ссылки на частично откомпилированные модули, что приблизительно соответствует опережающему описанию подпрограммы. Если интерфейсные части любых двух модулей независимы (это непременное условие!), Турбо Паскаль сможет идентифицировать все глобальные идентификаторы в каждом из модулей, после чего откомпилирует тела модулей обычным способом.
Алгоритм компиляции модулей
При трансляции программы или модуля, использующего другие модули, компилятор последовательно отыскивает файлы, содержащие коды используемых модулей, с тем, что¬бы подключить их к компилируемой программе. При этом компилятор работает по следующей схеме:
1) Компилятор просматривает содержимое системного биб-лиотечного файла модулей TURBO.TPL (Turbo Pascal Library). Этот файл будет кратко описан далее в этом раз¬деле.
2) Если искомый модуль не найден в файле TURBO. TPL, то компилятор осуществляет поиск соответствующего TPU-файла в ТЕКУЩЕМ каталоге.
3) Если в текущем каталоге нужный файл не найден, то по¬иск продолжается в каталогах, заданных в альтернативе Options/ Directories/Unit Directories для интегри¬рованной среды или в параметре /U вызова ТРС–компилятора.
4) Если на предыдущих шагах файл не найден, то компиля¬тор прекращает работу и выдает диагностическое сообщение об ошибке.
5) Если компилятор активизирован посредством альтернатив Compile/Make или Compile/Build, то вышеуказан¬ные шаги проводятся в поисках ИСХОДНЫХ ТЕКСТОВ ис¬пользуемых модулей, которые будут оттранслированы перед трансляцией самой программы. При этом подразуме¬вается, что имя файла с текстом модуля совпадает с име¬нем модуля и имеет расширение .PAS. Как было указано, первый шаг компилятора при поиске используемых модулей состоит в анализе системного файла TURBO.TPL. Этот файл имеет специальную структуру и пред¬назначен для компактного хранения и быстрого доступа к наиболее часто используемым модулям. Обычно в этом фай¬ле содержатся несколько системных (стандартных) модулей, однако с помощью специальной служебной программы TPUMOVER можно произвольным образом конструировать файл TURBO.TPL, включая в него нужные модули и удаляя неиспользуемые.

1.7 Доступ к объявленным в модуле объектам
Пусть, например, мы создаем модуль, реализующий арифметику комплексных чисел (напомню, что такая арифметика ни в стандартном Паскале, ни в Турбо Паскале не предусмотрена). К сожалению, в Турбо Паскале нельзя использовать функции, значения которых имели бы структурированный тип (запись, например), поэтому арифметика комплексных чисел реализуется четырьмя процедурами:
{UNIT Cmplx};
INTERFACE
{.............................................}
type
complex = record;
re, Im : real;
end
Procedure AddC (x, у : complex: var z: complex);
Procedure SubC (x, у : complex; var z: complex);
Procedure MulC (x, у : complex; var z: complex);
Procedure DIvC (x, у : complex; var z: complex);
const
с : complex = (re : 0.1; Im : -1);
IMPLEMENTATION
{..........— . — .......... — -- — ——...... }
PROCEDURE AddC;
begin
z.re := x.re + y.re;
z. Im := x . im + у. Im;
end {AddC};
PROCEDURE SubC;
begin
z .re := x.re - y.re;
z . im := x.Im - y. Im;
end {SubC};
PROCEDURE MulC;
begin
z.re := x.re * y.re - x.im * y.im;
z.lm := x.re * y.im + x.im * y.re;
end {MulC};
PROCEDURE DivC;
var zz : real;
begin
zz :=sqr(y.re) + sqr(y.im);
z.re := (x.re * y.re + x.im * y.im) / zz;
z.lm := (x.re * y.im - x.lm * y.re) / zz;
end {DIvC}:
END.
Текст этого модуля следует поместить в файл CMPLX.PAS. Его можно откомпилировать, создав TPU-файл, после чего программе станут доступны процедуры из новой библиотеки.























2 Лабораторные работы по созданию пользовательских модулей в Паскаль
2.1 Лабораторная работа № 1 «Написание программы на языке Паскаль с использованием разработанного собственного модуля».
Цель работы: формирование знаний умений по работе с модулями. Приобретение навыков создания собственных модулей.
Краткие теоретические сведения
Богатство алгоритмических возможностей Паскаля в значительной степени достигается благодаря использованию модулей.
Модуль представляет собой набор констант, типов данных, переменных, процедур и функций. Каждый модуль по своей структуре аналогичен отдельной программе.
Модуль – программная единица, текст которой компилируется независимо (автономно).
Вместе с тем, структура модуля позволяет использовать его как своеобразную библиотеку описаний. Паскаль располагает 8-мью стандартными (встроенными) модулями. Это System, Dos, Overlay, Graph, CRT, Printer, Turbo3, Graph3. Два последних модуля предназначены для поддержки программ, написанных на Турбо-Паскале версии 3.0.
Наряду с использованием стандартных модулей каждый программист имеет возможность организации собственных (пользовательских) модулей.
Структура любого следующего модуля имеет вид:
Unit (имя модуля);
ИНТЕРФЕЙСНАЯ ЧАСТЬ
Interface
Uses (список используемых модулей);
{открытые объявления}
Type
Var
Procedure
Function
РЕАЛИЗАЦИОННАЯ ЧАСТЬ
Implementation
Uses (список используемых модулей);
{собственные объявления}
Type
Var
{процедуры и функции}
Procedure
Function
ИНИЦИАЛИАЦИОННАЯ ЧАСТЬ
Begin
… {основной блок модуля}
End.
Имя модуля записывается за ключевым словом UNIT. При выборе имени модуля необходимо учитывать одну особенность: имя модуля должно совпадать с именем файла, в котором он хранится.
Далее записывается раздел интерфейсной части (за ключевым словом Interface). Эта часть модуля является доступной (“видимой”) для любой программы, использующей этот модуль. То есть объявленные в этом разделе константы, типы данных, переменные, процедуры и функции, могут использоваться в любой другой программе. В свою очередь, в разделе интерфейса могут указываться другие используемые модули (их список следует за ключевым словом Uses). При этом все объекты, объявленные в интерфейсах этих модулей, могут быть использованы в любом объявлении в интерфейсе данного модуля.
Следующим в структуре модуля описывается раздел реализации (за ключевым словом Implementation). В этом разделе могут использоваться все объекты, описанные в разделе интерфейса. Вместе с тем, здесь могут объявляться свои константы, типы данных, переменные процедуры и функции. Они могут быть использованы только в данном разделе реализации и в этом смысле являются “не видимыми”. Это же ограничение относится и к интерфейсам других модулей, список которых следует за ключевым словом Uses. Таким образом, различие всех описаний, содержащихся в разделе интерфейса и реализации заключается в сфере их использования.
Раздел реализации модуля начинается ключевым словом Imlementation и заканчивается end. Но если между ними появляется ключевое слово begin, то получившийся составной оператор begin…end становится разделом инициализации модуля. Раздел инициализации обычно используется для открытия файлов и для формирования значений структур данных и переменных.
При выполнении программы, использующей модули, их разделы инициализации вызываются раньше загрузки самой программы. Для того, чтобы использовать модули в программах их имена следует указать в разделе подключения модулей Uses.
Например, вы разработали программу, которая наряду со стандартным модулем Crt использует ваш разработанный модуль с именем Modul. Тогда, в программе следует указать список используемых модулей в следующем виде:
Program Pr;
Uses Crt, Modul;

Модули транслируются отдельно. В отличие от основных программ результатом трансляции которых будут файлы с расширением EXE модули получают расширение TPU. Полученные в результате трансляции TPU-файлы можно подсоединить к стандартному файлу TUPBO.TPL с помощью утилиты TRUMOVER.EXE. Если этого не делать, то при трансляции самой программы все используемые модули (TPU-файлы) присоединяться к ней автоматически. Если в каком-либо из используемых модулей были внесены изменения, то при трансляции программы, все модифицирующие модули также будут предварительно перетранслированы (эту функцию реализует интегрированная среда).
Пример написания собственного модуля
Разработку собственного модуля рассмотрим на следующем примере:
Пусть дано задание: разработать личную библиотеку, включив в неё процедуры:
- ввода элементов числовой матрицы размером N*N;
- транспонирования матрицы;
- вывода результирующей матрицы.
В основной программе ввести размер матрицы N.
Начнём разработку модуля, который будет носить название Matrix. Программно это будет выглядеть так:
Uniy Matrix;
{Зарезервированное слово Unit служит для указания имени библиотеки. Это имя должно совпадать с именем PAS-файла библиотеки (т.е библиотека Matrix должна находиться в файле Matrix.Pas), а иначе компилятор даст ошибку при попытке использования такой библиотеки}
Interface
{Секция Interface содержит описания общедоступных типов данных, констант, процедур и функций. Т.е. все, что здесь находится, можно будет использовать при подключении данной библиотеки}
Type
TMatrix=array [1..10,1..10] of Integer; {Квадратная матрица}
procedure MatrInput (Var m: TMatrix; n : Integer); {ввод матрицы}
procedure MatrOutput (Var m: TMatrix; n : Integer); {вывод матрицы}
procedure MatrTransp (Var m: TMatrix; n : Integer); {транспонирование}
Implementation
{Секция Implementation содержит реализацию тел процедур и функций, описанных в Interface. Также здесь могут содержаться типы данных, константы, процедуры и функции, необходимые для работы, но которые не будут видны программе при подключении библиотеки.}
{Процедура обмена местами двух элементов матрицы (x1, y1) и (x2, y2). Эта процедура используется при транспонировании матрицы, но её нельзя вызвать при подключении, так как она не объявлена в секции Interface}
procedure Swap (Var m: TMatrix; x1,y1,x2,y2 : Integer);
var
temp : Integer;
begin
temp:=m[x1,y1];
m[x1,y1]:=m[x2,y2];
m[x2,y2]:=temp;
end;
{Ввод матрицы с клавиатуры. Параметры процедуры здесь не указаны, так как они есть в секции Interface}
procedure MatrInput;
var
i,j : Integer;
begin
for i:=1 to n do
begin
Write (i:3,’-я строка:’);
for j:=1 to n do Read(m[i,j]);
ReadLn;
end;
end;
{Транспонирование матрицы.}
procedure MatrTransp;
var
i,j : Integer;
begin
for i:=1 to n-1 do
for j:=i+1 to n do
Swap (m,i,j,j,i);
end;
{Вывод матрицы на экран.}
procedure MatrOutput;
var
i,j : Integer;
begin
for i:=1 to n do
begin
Write(i:3,’-я строка :’);
for j:=1 to n do Write (m[i,j]:4);
WriteLn;
end;
end;
{Эта секция может использоваться для инициализации работы библиотеки.}
Begin
End.
Создание модуля закончено. Теперь необходимо создать файл, который будет содержать текст основной программы, в которой будет подключаться разработанный выше модуль.
{Это отдельный файл, содержащий основную программу}
Uses
Crt, {Библиотека стандартных процедур управления экраном и клавиатурой}
Matrix; {Наш разработанный модуль-библиотека работы с квадратными матрицами (личная)}
Var
m : TMatrix; {Объявляем матрицу – максимальный размер 10*10}
n : Integer; {Размер матрицы}
Begin
{Повторяем ввод размера, пока не будет введено корректное значение}
repeat
ClrScr;
Write (‘Введите размер матрицы (1..10):’);
ReadLn(n);
until (n>=1) and (n<=10);
WriteLn;
WriteLn(‘Введите матрицу размера’,n,’*’,n,’по строкам:’);
MatrInput (m,n); {вызов процедуры ввода матрицы, определённой в модуле Matrix}
{Транспонируем её}
MatrTransp (m,n); {вызов процедуры транспонирования матрицы, определённой в модуле Matrix}
{Выведем результат на экран}
WriteLn;
WriteLn (‘Транспонированная матрица :’);
MatrOutput (m,n); {вызов процедуры вывода матрицы, определённой в модуле Matrix}
End.
Порядок выполнения работы
1. Изучить теоретические сведения по теме «Модули в Паскале».
2. Получить у преподавателя индивидуальное задание. Разработать личную библиотеку, включив в неё процедуры, определённые в задании.
3. Показать работающую программу преподавателю.
4. Ответить на контрольные вопросы.
Контрольные вопросы
1. Стандартные модули в Паскале.
2. Структура модуля.
3. Ключевые слова Unit, Interface, Implementation. Описание каждого раздела.
4. Концепция разработки собственного модуля. Пример программы.
Варианты заданий

1 Создать модуль, содержащий процедуры иили функции:
- длина окружности;
- площадь круга;
- длина дуги;
-площадь сектора.
Написать программу, демонстрирующую работу созданного модуля.
2 Создать модуль, содержащий процедуры иили функции:
- ввод элементов массива с клавиатуры;
- среднее арифметическое элементов массива;
- найти в массиве указанный элемент и вывести его индекс.
Написать программу, демонстрирующую работу созданного модуля.
3 Создать модуль, содержащий процедуры иили функции:
- периметр треугольника, заданного координатами своих вершин;
- площадь треугольника по трем сторонам;
- площадь кольца по заданным внешнему и внутреннему радиусам.
Написать программу, демонстрирующую работу созданного модуля.
4 Создать модуль, содержащий процедуры иили функции:
- вывод элементов массива на экран;
- среднее геометрическое элементов массива;
- циклический сдвиг элементов массива на k элементов.
Написать программу, демонстрирующую работу созданного модуля.
5 Создать модуль, содержащий процедуры иили функции:
-площадь поверхности шара;
- объем шара;
- площадь сферического сегмента;
- объем шарового сегмента и объем шарового сектора.
Написать программу, демонстрирующую работу созданного модуля.
6 Создать модуль, содержащий процедуры иили функции:
- вычисление n-го члена арифметической прогрессии;
- сумма n первых членов арифметической прогрессии (2 способа).
Написать программу, демонстрирующую работу созданного модуля.
7 Создать модуль, содержащий процедуры иили функции:
- вычисление n-го члена геометрической прогрессии;
- сумма n первых членов геометрической прогрессии и бесконечно убывающей геометрической прогрессии;
- произведение первых n членов геометрической прогрессии.
Написать программу, демонстрирующую работу созданного модуля.
8 Создать модуль, содержащий процедуры иили функции:
- скалярное произведение векторов;
- векторное произведение векторов;
- смешанное произведение векторов.
Написать программу, демонстрирующую работу созданного модуля.
9 Создать модуль, содержащий процедуры иили функции:
- сложение и вычитание комплексных чисел;
- умножение комплексных чисел;
- деление комплексных чисел.
Написать программу, демонстрирующую работу созданного модуля.
10 Создать модуль, содержащий процедуры иили функции:
- площадь боковой поверхности цилиндра;
- площадь полной поверхности цилиндра;
- объем цилиндра.
Написать программу, демонстрирующую работу созданного модуля.
11 Создать модуль, содержащий процедуры иили функции:
- производная функции по определению, принимая ∆x=0,0001;
- вычислить сумму цифр заданного числа;
- определить число единиц, число десятков и число сотен трехзначного числа.
Написать программу, демонстрирующую работу созданного модуля.
12 Создать модуль, содержащий процедуры иили функции:
- ввод матрицы с клавиатуры;
- транспонировать матрицу;
- наибольший элемент матрицы.
Написать программу, демонстрирующую работу созданного модуля.
13 Создать модуль, содержащий процедуры иили функции:
- площадь боковой поверхности конуса;
- площадь полной поверхности конуса;
- объем конуса.
Написать программу, демонстрирующую работу созданного модуля.
14 Создать модуль, содержащий процедуры иили функции:
- периметр и площадь прямоугольника по известным сторонам;
- диагональ прямоугольника по известным сторонам;
- объем и площадь боковой поверхности параллелепипеда.
Написать программу, демонстрирующую работу созданного модуля.
15 Создать модуль, содержащий процедуры иили функции:
- умножение двух матриц;
- вычисление следа матрица;
- меняет местами две строки матрицы.
Написать программу, демонстрирующую работу созданного модуля.
16 Создать модуль, содержащий процедуры иили функции:
- периметр прямоугольного треугольника, зная его катеты;
- периметр равнобедренной трапеции по основаниям и высоте;
- площадь равнобедренной трапеции по основаниям и углу при большем основании.
Написать программу, демонстрирующую работу созданного модуля.
17 Создать модуль, содержащий процедуры иили функции:
- максимальный элемент главной диагонали;
- наименьший элемент матрицы;
- создать массив из элементов i-той строки.
Написать программу, демонстрирующую работу созданного модуля.
18 Создать модуль, содержащий процедуры иили функции:
- площадь боковой поверхности усеченного конуса;
- площадь полной поверхности усеченного конуса;
- объем усеченного конуса.
Написать программу, демонстрирующую работу созданного модуля.
19 Создать модуль, содержащий процедуры иили функции:
- упорядочить массив по возрастанию;
- сумма двух массивов;
- циклический сдвиг элементов массива на 1 элемент.
Написать программу, демонстрирующую работу созданного модуля.
20 Создать модуль, содержащий процедуры иили функции:
- произведение элементов главной диагонали;
- сумма элементов k-той строки;
- создание массива из четных элементов матрицы.
Написать программу, демонстрирующую работу созданного модуля.

2.2 Лабораторная работа № 2 «Разработка модулей. Turbo Pascal».
Цель работы: Закрепление знаний о модулях. Приобретение навыков разработки модулей, содержащих встроенные процедуры и функции.
Краткие теоретические сведения
Часто используемые процедуры и функции можно сгруппировать в один библиотечный файл (его называют модулем или Unit), откомпилировать и сохранить результаты компиляции на диске. После этого можно будет применять те или иные процедуры и функции из этого модуля в различных программах, обращаясь к ним лишь по имени. В разделе USES нужно лишь предварительно указать имя используемого модуля. Попытаемся создать свой собственный модуль. Назовём его My_Unit (Мой_Модуль). В него включим процедуру установки цвета фона и цвета символов (отображаемых на экране), а также функцию, вычисляющую площадь круга по известному радиусу.
Листинг такого модуля будет выглядеть так:
Unit My_Unit; {заголовок модуля}
{my_unit.pas}
INTERFACE {раздел объявлений}
USES
Crt;
{Заголовок доступных извне создаваемых библиотечных процедур и функций:}
Procedure FonSymb(ColorFon, ColorSymb: Byte);
Function S_Krug(R:Real):Real;
IMPLEMENTATION {раздел реализации}
{Процедура установки цвета фона и цвета символов, отображаемых на экране:}
PROCEDURE FonSymb(ColorFon, ColorSymb: Byte);
Begin
TextBackGround(ColorFon);
ClrScr;
TexrColor(ColorSymb);
End;
{Функция, вычисляющая площадь круга по известному радиусу:}
FUNCTION S_Krug(R: Real): Real;
Begin
S_Krug:=Pi*Sqr(R);
End;
BEGIN {может отсутствовать, если между BEGIN и END нет операторов}
END.
Сохраните листинг на диске под именем my_unit.pas.
Теперь нужно выполнить компиляцию этого модуля с сохранением результатов компиляции на диске. Для этого выберите в строке меню пункт Compile и установите для опции Destination значение – Disk, нажмите [Alt-F9]. В результате компиляции модуля получим не exe-файл (как после компиляции обычной программы), а tpu-файл, то есть my_unit.tpu. В заключение нужно удостовериться, чтобы этот файл находился в каталоге TPU, где хранятся все остальные модули.
Пример программы
Напишем простую линейную программу, использующую этот модуль.
USES
My_Unit;
VAR
Radius: Real; {радиус круга}
BEGIN
{Вначале работают операторы (если они есть) между BEGIN и END модуля My_Unit}
FonSymb(1,14);
Write(‘Введите радиус круга (в мм): ’);
ReadLn(Radius);
WriteLn(‘Площадь круга равна ‘,S_Krug(Radius):6:2,’ кВ.мм’);
ReadLn;
END.
Обратите внимание на то, что в разделе USES объявлен лишь модуль My_Unit и нет Crt. Тем не менее, с помощью одного только оператора FonSymb мы смогли задать нужный цвет фона, очистить экран монитора, что раньше удавалось сделать с помощью трёх операторов.
Порядок выполнения работы
1. Изучить теоретические сведения по теме «Модули, содержащие встроенные процедуры и функции».
2. Получить у преподавателя индивидуальное задание. Разработать собственные модули, включив в неё процедуры, определённые в задании.
3. Показать работающую программу преподавателю.
4. Ответить на контрольные вопросы.
Контрольные вопросы
1. Что такое «модуль»?
2. Как перевести на английский слово «модуль»?
3. Что дает использование модулей?
4. С какими модулями вам приходилось работать ранее?
5. Как выглядит заголовок модуля?
6. Сколько может быть процедур и функций в модуле?
7. Какое расширение будет иметь файл, содержащий результаты откомпилированного модуля?
Варианты заданий

1 В основной программе вводятся стороны треугольника a, b, c. В модуле проверяются неравенства треугольника (a<b+c; b<a+c; c<a+b) и вычисляется площадь треугольника. Ввести данные двух треугольников и вывести результаты.
2 В основной программе вводятся внешний R и внутренний r радиусы кольца. В модуле рассчитывается площадь кольца. Ввести данные двух колец и вывести результаты.
3 Башня представляет сочетание цилиндра с известными радиусом и высотой и полушара с радиусом, равным радиусу цилиндра. Разработать модуль, в котором вычисляется объем башни, и основную программу с вводом данных для двух башен и выводом результатов.
4 В основной программе вводятся начальная скорость снаряда v и угол , под которым вылетает снаряд. В модуле рассчитываются координаты снаряда в момент времени t (до падения на землю): x = vt cos ; y = vt sin - gt2/2. Напечатать координаты начальной точки, верхней точки, конечной точки траектории.
5 В модуле по сопротивлениям трех резисторов, соединенных последовательно, определяется общее сопротивление. В основной программе вводятся данные двух троек резисторов и выводятся результаты.
6 В модуле по емкостям трех конденсаторов, соединенных последовательно, определяется общая емкость. В основной программе вводятся данные двух троек конденсаторов и выводятся результаты.
7 В модуле по сопротивлениям трех резисторов, соединенных параллельно, определяется общее сопротивление. В основной программе вводятся данные двух троек резисторов и выводятся результаты.
8 В модуле по емкостям трех конденсаторов, соединенных параллельно, определяется общая емкость. В основной программе вводятся данные двух троек конденсаторов и выводятся результаты.










Контрольные вопросы
1. Какое расширение имеет исходный файл модуля? Откомпилированный файл?
2. Какие разделы имеются в модуле? Какой раздел модуля доступен для программ и других модулей? Какой недоступен?
3. Какие ресурсы модуля могут использоваться в программах?
4. Каковы преимущества использования модулей?
5. Имеется ли в разработанном вами модуле раздел инициализации?
6. Назначение раздела инициализации модуля.
7. В каком разделе модуля помещаются тела процедур и функций?




















Заключение
Целью данной работы была разработка комплекса лабораторных работ по теме «Создание пользовательских модулей в Pascal»
Для достижения поставленной цели были решены следующие задачи:
 проанализирована учебно-методическая литература по проблеме исследования;
 рассмотрена среда программирования Turbo Pascal и ее структура;
 изучены модули в Turbo Pascal;
 разработаны лабораторные работы по теме «Создание пользовательских модулей в Pascal», содержащие практическое применение теоретического материала по темам: создание пользовательских модулей; работа с модулями.
Таким образом, задачи были решены, цели достигнуты.

















Список используемых источников
1. Абрамов В.Г., Трифонов Н.П., Трифонова Г.Н. Введение в язык Паскаль. - М.: Наука, 1988. - 320 с.
2. Абрамов С.А., Зима Е.В. Начала программирования на языке Паскаль. - М.: Наука, 1987. - 112 с.
3. Вирт Н. Алгоритмы и структуры данных./Пер. с англ. М.: Мир, 1989. - 360 с.
4. Грогоно П. Программирование на языке Паскаль. - М.: Мир, 1982. - 382 с.
5. Дантеманн Дж., Мишел Дж., Тейлор Д. Программирование в среде Delphi: Пер. с англ. - Киев: НИПФ “ДиаСофтЛтд.”, 1995. - 608 с.
6. Епанешников А., Епанешников В. Программирование в среде Турбо Паскаль 7.0. - М.: ДИАЛОГ-МИФИ, 1993. - 288 с.
7. Йенсен К., Вирт Н. Паскаль. Руководство для пользователя и описание языка: Пер. с англ. - М.: Финансы и статистика, 1982. - 151 с.
8. Матчо Дж., Фолкнер Д.Р. Delphi: Пер.с англ.- М.: БИНОМ, 1995. - 464 с.
9. Орлик С.В. Секреты Delphi на примерах: - М.: БИНОМ. - 316 с.
10. Перминов О.Н. Программирование на языке Паскаль. - М.: Радио и связь, 1988. - 224 с.
11. Пильшиков В.Н. Сборник упражнений по языку Паскаль: Учеб. пособие для вузов. - М.: Наука, 1989. - 160 с.
12. Прайс Д. Программирование на языке Паскаль: Практ. руководство. - М.: Мир, 1987. - 232 с.
13. Рубенкинг Н. Турбо Паскаль для Windows: В 2 т.; Пер. с англ. - М.: Мир, 1993. - 536 с.
14. Фаронов В.В. Турбо Паскаль. В 3-х книгах. Книга 1. Основы Турбо Паскаля. - М.: Учеб.-инж.центр МВТУ-ФЕСТО ДИДАКТИК, 1992. - 304 с.
15. Фаронов В.В. Паскаль и Windows. - М.: Учеб.-инж.центр МВТУ-ФЕСТО ДИДАКТИК, 1994. - 539 с.
16. Фаронов В.В. Практика Windows-программирования. М.: Информпечать, 1996. - 247 с.
17. Федоров А., Рогаткин Д. Borland Pascal в среде Windows. - Киев: Диалектика, 1993. - 656 с.
18. Форсайт Р. Паскаль для всех: Пер. с англ.- М.: Машиностроение, 1986. - 288 с.




























Приложение 1

{$N+}
unit func1;
interface
type
float = Extended;
const
Infinity = 1.0E+4932;
function Tan(x : float) : float;
function ArcSin(x : float) : float;
function ArcCos(x : float) : float;
function Degrees_to_Radians(Degrees : float) : float;
function Radians_to_Degrees(Radians : float) : float;
function Sinh(x : float) : float;
function Cosh(x : float) : float;
function Tanh(x : float) : float;
function Log10(x : float) : float;
function Power(x, Exponent : float) : float;
implementation
const
Radians_Per_Degree = Pi / 180;
Degrees_Per_Radian = 180 / Pi;
Ln10 = 2.3025850930;
MaxValue = 88.029619;
function Tan(x : float) : Float;
var
Consine, Tangent : float;
begin
Consine := Cos(x);
if Cosine := 0.0 then
if Sin(x)>=0 then
Tan := Infinity
else
Tan := -Infinity
else
begin
Tangent := Sin(x) / Cosine;
if Tangent > Infinity then
Tan := Infinity
else
if Tangent < -Infinity then
Tan := -Infinity
else
Tan := Tangent;
end;
end;
function ArcSin(x : float) : float;
begin
if Abs(x) = 1.0 then
ArcSin := Pi / 2.0
else
ArcSin := ArcTan(x / Sqrt(1 – x * x));
end;
function ArcCos(x : float) : float;
var
Result : float;
begin
if x = 0.0 then
ArcCos := Pi / 2.0
else
begin
Result := ArcTan(sqrt(1 – x * x) / x);
if x < 0.0 then
ArcCos := Result + Pi
else
ArcCos := Result;
end;
end;
function Degrees_to_Radians(Degrees : float) : float;
begin
Degrees_to_Radians := Degrees * Radians_Per_Degree;
end;
function Radians_to_Degrees(Radians : float) : float;
begin
Radians_to_Degrees := Radians * Degrees_Per_Radian;
end;
function Sinh(x : float) : float;
var
t : float;
begin
if x > MaxValue then
Sinh := Ifinity
else
if x < -MaxValue then
Sinh := -Infinity
else
begin
t := Exp(x);
Sinh := 0.5 * (t – 1 / t);
end;
end;
function Cosh(x : float) : float;
var
t : float;
begin
if Abs(x) > MaxValue then
Cosh := Infinity
else
begin
t := Exp(x);
Cosh := 0.5 * (t + 1 / t);
end;
end;
function Tanh(x : float) : float;
begin
Tanh := Sinh(x) / Cosh(x);
end;
function Log10(x : float) : float;
begin
Log10 := Ln(x) / Ln10;
end;
function Power(x, Exponent : float) : float;
begin
if x > 0.0 then
Power := Exp(Exponent * Ln(x))
else if x = 0.0 then
Power := 0.0
else
WriteLn ( ‘ Основание степени отрицательно! ’ );
end;
begin
end.

© Copyright 2012-2020, Все права защищены.