end.

1.3.2. Функции числовых параметров.

Название	Значение
abs(x)	модуль x
cos(x)	косинус x
frac(x)	дробная часть x
int(x)	целая часть x (т.е. ближайшее целое, не превосходящее x)
pi	|число
round(x)	x, округлённое до целого
sin(x)	синус x
sqr(x)	квадрат x
sqrt(x)	квадратный корень из x

1. Оператор if.
Иногда требуется, чтобы часть программы выполнялась не всегда, а лишь при выполнении некоторого условия (а при невыполнении этого условия выполнялась другая часть программы). В этом случае пользуются оператором условного выполнения, который записывается в следующем виде:
if then else;
Под оператором понимается либо одиночный оператор (например, присваивания, вызова процедуры), либо такой составной оператор, состоящий из нескольких простых операторов, помещённых между словами begin и end. Важно заметить, что перед else не ставится точка с запятой. Часть else может и отсутствовать.
Пример 1: пусть требуется найти число m=max(a,b). Этой задаче
соответствует следующий фрагмент программы на Паскале:
if a>b then m:=a else m:=b;
Пример 2: (без else) пусть дано целое число i. Требуется оставить его
без изменения, если оно делится на 2, и вычесть из него 1, если это не так.
var i: integer;
if i mod 2 = 1 then i:=i-1; {else - ничего не делать}
Пример 3: (с использованием составного оператора). Пусть даны две переменные типа real. Требуется поменять местами значения этих переменных, если a1>a2.
var a1,a2,buf :real;
if a1>a2 then begin
buf:=a1;
a1:=a2;
a2:=buf;
end;
 Пример при подсчете суммы натуральных чисел от 1 до 100:
Var i,sum: integer;
begin
sum:=0; i:=0;
repeat
i:=i+1;
sum:=sum+i;
until i=100;
writeln ('Сумма равна: ',sum);
readln;
end.
Важно заметить, что операторы стоящие внутри цикла repeat (иначе в теле цикла) выполняются хотя бы один раз (только после этого проверяется условие выхода).
Этот цикл записывается так: while do . (Пока условие истинно, выполнять оператор). Суть в следующем: пока условие истинно, выполняется оператор (в этом случае оператор может не выполниться ни разу, т.к. условие проверяется до выполнения).
1. Символьный тип
Тип данных, переменные которого хранят ровно один символ (букву, цифру, знак препинания и т.п.) называется символьным, а в Паскале — char. Объявить переменную такого типа можно так: var ch: char;. Для того чтобы положить в эту переменную символ, нужно использовать оператор присваивания, а символ записывать в апострофах, например: ch:='R';. Для символьных переменных возможно также использование процедуры readln, например:
 write(‘Выйти из игры? (Да/Нет)’); readln(ch);
 if ch=’Д’ then ... {выходить}...
 else ...{продолжать}...;
Символьные переменные в памяти компьютера хранятся в виде числовых кодов, иначе говоря, у каждого символа есть порядковый номер. К примеру, код пробела равен 32, код ‘A’ — 65, ‘B’ — 66, ‘C’ — 67, код символа ‘1’ — 48, ‘2’ — 49, ‘.’ — 46 и т. п. Некоторые символы (с кодами, меньшими 32) являются управляющими, при выводе таких символов на экран происходит какое-либо действие, например, символ с кодом 10 переносит курсор на новую строку, с кодом 7 — вызывает звуковой сигнал, с кодом 8 — сдвигает курсор на одну позицию влево. Под хранение символа выделяется 1 байт (байт состоит из 8 бит, а бит может принимать значения 0 или 1), поэтому всего можно закодировать 28 = 256 различных символов. Кодировка символов, которая используется Турбо-Паскале, называется ASCII (American Standard Code for Information Interchange — американский стандартный код для обмена информацией).
Для того чтобы получить в программе код символа нужно использовать функцию chr, например:
 var i: byte; {число, занимающее 1 байт, значения — от 0 до 255}
  ch: char;
 ...
 readln(i); writeln ('символ с кодом ',i,' — это ',chr(i));
Если в качестве кода используется конкретное число, а не выражение и не переменная, то можно использовать символ «#», скажем так: ch:=#7;. Для того перехода от кода к символу используется функция ord (от слова ordinal — порядковый). Имеющиеся знания позволяют нам написать программу, которая выдаёт на экран таблицу с кодами символов:
program ASCII;
var ch: char;
begin
for ch:=#32 to #255 do write(ord(ch),'—>',ch,' ');
readln;
end.
В этой программе в качестве счётчика цикла была использована символьная переменная, это разрешается, поскольку цикл for может использовать в качестве счётчика переменные любого типа, значения которого хранятся в виде целых чисел.
С использованием кодов работают ещё две функции, значения которых символьные:
 1. succ (от succeedent — последующий), она выдаёт символ со следующим кодом.
 2. divd (от divdecessor — предшественник), выдаёт символ с предыдущим кодом.
Если попытаться в программе получить succ(#255) или divd(#0), то возникнет ошибка. Пользуясь этими функциями можно переписать предыдущую программу и по-другому:
ch:=#32;
while ch<>#255 do begin
write(ord(ch),'—>',ch,' ');
ch:=succ(ch);
end;
Сравнение символов. Также как и числа, символы можно сравнивать на =, <>, <=, >=. В этом случае Паскаль сравнивает не сами символы, а их
коды. Таблица ASCII составлена таким образом, что коды букв (латинских и большинства русских) возрастают при движении в алфавитном порядке, а коды цифр расположены по порядку: ord(‘0’)=48, ord(‘1’)=49, ... ord(‘9’)=57. Сравнения символов можно использовать везде, где требуются логические выражения: в операторе if, в циклах и т.п.
2. Строковый тип
Для хранения строк (то есть последовательностей из символов) в Турбо Паскале имеется тип string. Значениями строковых переменных могут быть последовательности различной длины (от нуля и более, длине 0 соответствует пустая строка). Объявить строковую переменную можно двумя способами: либо var s: string; (максимальная длина строки — 255 символов), либо var s: string[n]; (максимальная длина — n символов, n — константа или конкретное число).
Для того чтобы положить значение в строковую переменную используются те же приёмы, что и при работе с символами. В случае присваивания конкретной строки, это строка должна записываться в апострофах (s:='Hello, world!'). Приведём простейший пример со строками: программа спрашивает имя у пользователя, а затем приветствует его:
Program Hello;
var s: string;
begin
write('Как Вас зовут: ');
readln(s);
write('Привет, ',s,'!');
readln;
end.
Хранение строк. В памяти компьютера строка хранится в виде последовательности из символьных переменных, у них нет индивидуальных имён, но есть номера, начинающиеся с 1). Перед первым символом строки имеется ещё и нулевой, в котором хранится символ с кодом, равным длине строки. Нам абсолютно безразлично, какие символы хранятся в байтах, находящихся за пределами конца строки. Рассмотрим пример. Пусть строка s объявлена как string [9], тогда после присваивания s:=’Привет’; она будет хранится в следующем виде:

Номер байта	0	1	2	3	4	5	6	7	8	9
Содержимое	|#6	‘П’	‘р’	‘и’	‘в’	‘е’	‘т’	‘ю’	‘s’	‘%’

Для того чтобы в программе получить доступ к n-му символу строки используется запись s[n]. Если поменять значение s[0] то это отразится на длине строки. В следующем примере из строки 'Привет' мы сделаем 'Привет!':
s[0]:=#7; s[7]:='!';.
Сравнение строк. Строки сравниваются последовательно, по символам. Сравниваются первые символы строк, если они равны — то вторые, и т. д. Если на каком-то этапе появилось различие в символах, то меньшей будет та строка, в которой меньший символ. Если строки не различались, а затем одна из них закончилась, то она и считается меньшей. Примеры: 'ананас'<'кокос', 'свинья'>'свинина', ''<'A', 'hell'<'hello'.
Склеивание (конкатенация) строк. К строкам можно применять операцию «+», при этом результатом будет строка, состоящая из последовательно записанных «слагаемых». Пример: после действия s:= 'abc'+'def'+'ghi'; переменная s будет содержать ‘abcdefghi’.
Процедуры и функции для работы со строками. Наиболее часто употребляется функция length(s: string): integer (после двоеточия записан тип значения, возвращаемого функцией, в нашем случае — целое число). Эта функция возвращает длину строки s.
3. Перечисляемый тип
Предположим, что нам требуется переменная для хранения дня недели. В этом случае можно воспользоваться целым типом (например byte) и хранить дни недели в виде чисел 1, 2, ... 7, но это будет не очень наглядно. Турбо Паскаль предоставляет более удобный вариант, а именно создание перечислимого типа, например, такого:
 type Days = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
После этого можно завести переменную этого типа (var day: Days;) и использовать её. Ниже приведены примеры использования:
 day:=Wed;
 ...
 if day>Fri then writeln('Сегодня выходной');
 ...
 if day=Mon then writeln('Началась рабочая неделя');
Как вы уже заметили значения перечислимого типа можно сравнивать, при этом меньшим считается то, которое объявлено раньше (левее) в определении типа.
Для переменных перечисляемых типов возможно применение функций succ и divd, например, succ(Wed) дает Thu, Pred(Sun) дает Sat. Если попытаться написать Pred(Mon) или Succ(Sun), то уже на этапе проверки программы компилятором произойдет ошибка.
Хранение значений перечисляемого типа устроено внутри довольно просто: хранятся целые числа от 0 до n, в нашем случае n = 6. Существует функция Ord, которая позволяет получить то число, в виде которого хранится какое-либо значение перечисляемого типа, например Ord(Wed) дает
При необходимости можно получить значение перечисляемого типа по его численному представлению, например, Days(1) есть Tue. После всего сказанного можно заметить, что при сравнении величин перечисляемого типа в действительности сравниваются их порядковые номера (Ord).
Пример использования перечисляемых типов:
Пусть корабль может двигаться только по четырем направлениям: на север, на запад, на юг и на восток, то есть текущее направление движения определяется переменной типа Directions = (North, West, South, East);. Этому кораблю можно подавать приказы следующих типов: вперёд, назад, влево, вправо, то есть любой приказ задать переменной типа Orders = (Ahead, Back, Left, Right);. Пусть корабль двигался по направлению d1, после чего ему дали приказ p. Программа должна определить, в каком направлении корабль будет двигаться после выполнения приказа.
Program Ship;
type Courses = (North, West, South, East);
Orders = (Ahead, Back, Left, Right);
var d1, d2: Courses;
p: Orders;
i: integer;
s: string;
begin {Запрашиваем у пользователя информацию о курсе и приказе}
writeln('Введите первоначальный курс корабля ');
write('(0-север, 1-запад, 2-юг, 3-восток) ');
readln(i);
d1:=Courses(i);
writeln('Введите приказ, данный кораблю ');
write('(0-прямо, 1-назад, 2-влево, 3-вправо) ');
readln(i);
p:=Orders(i); {Определяем новый курс}
case p of
Ahead : d2:=d1;
Back : d2:=Courses((ord(d1)+2) mod 4);
Left : d2:=Courses((ord(d1)+1) mod 4);
Right : d2:=Courses((ord(d1)+3) mod 4); {-1 - нельзя, так как (Ord(North)-1) mod 4 = -1}
end; {Выводим результат на экран}
case d2 of
North : s:='север';
West : s:='запад';
South : s:='юг';
East : s:='восток';
end;
writeln('Теперь корабль движется на '+s);
readln;
end.
4. Ограниченный тип
Этот тип также рассмотрим на примере. Пусть в некоторой переменной нужно хранить текущее число, то есть номер дня в месяце. В Турбо Паскале можно задать тип DaysInMonth = 1..31;. Переменные и константы этого типа могут принимать только такие значения, если попытаться задать что-либо другое, то компилятор выдаст ошибку. В качестве границ могут употребляться и отрицательные числа, например Temperature = - 60..50;
В качестве базового типа (то есть типа, из которого выбирается диапазон значений) могут использоваться почти все порядковые типы, то есть те, которые хранятся в виде целых чисел. К порядковым типам относятся: все целые типы (byte, integer, и т. п.), char, boolean, перечисляемые типы и ограниченные типы. В качестве базового типа нельзя использовать лишь сам ограниченный тип (трудно представить, как это можно сделать). С учетом этого правила допустимы такие объявления типов:
type SmallLatin = 'a'..'z'; {малые латинские буквы}
MyBoolean = True..False; {хотя это и бессмысленно}
Holidays = Sat..Sun; {выходные}
Нельзя в качестве базового типа употребить какой-либо вещественный тип, следующее объявление приведет к ошибке:
type Wrong = -1.25..1.25;
Заметим, что функции Ord, Succ и Pred могут применяться к любым порядковым типам, и, в частности, к ограниченным.
Для вывода текста на экран используются две процедуры:
1. OutText(s: string). Эта процедура выводит строку s начиная с текущей позиции, то есть левый верхний угол выводимой строки находится в текущей позиции (по умолчанию это так). Текущая позиция задаётся, например, с помощью MoveTo.
2. OutTextXY(x,y: integer; s: string). Используется для вывода строки в конкретной позиции.
Если требуется вывести какие либо числа, то предварительно требуется преобразовать их в строку, например, с помощью процедуры Str.
 Пример:
var r: integer;
s: string;
Str(r,s);
OutTextXY(100,200,’Результат=’+s);
Турбо Паскаль позволяет использовать несколько различных шрифтов для вывода текста. Кроме того, можно менять направление вывода текста, а также размер символов. В этих целях используется процедура SetTextStyle(Font, Direction, CharSize: word). Перечислим возможные константы и значения для параметров этой процедуры.
Font (шрифт):
DefaultFont (шрифт 8x8 (по умолчанию)
TriplexFont (полужирный шрифт);
SmallFont (тонкий шрифт);
SansSerifFont (шрифт без засечек);
GothicFont (готический шрифт);
Direction (ориентация и направление вывода символов):
0 (привычный вывод слева направо
1 (снизу вверх (надпись «положена на бок»)
2 (слева направо, но «лежачими» буквами.
Size (размер шрифта (целые числа от 0 до 10).
Другая возможность при работе с текстом (это выравнивание его относительно задаваемых координат вывода. Для этого используется процедура SetTextJustify(horiz,wert: word). Horiz указывет как текст расположен относительно заданной позиции по горизонтали, а vert (по вертикали. Возможные константы:
 для horiz:
 LeftText (указанная позиция является левым краем строки);
 CenterText (позиция является серединой выводимой строки);
 RightText (правым краем строки);
 для vert:
 BottomText (позиция находится на нижнем крае изображения);
 CenterText (по центру);
 TopText (позиция является верхним краем изображения);
 Процедура (последовательность действий (записанных на Паскале), названная каким-либо именем. Для того чтобы выполнить эту последовательность, нужно в соответствующем месте программы указать её имя (так, например, для очистки экрана при работе с графикой мы указываем ClearDevice;). Кроме того, что программа становится при использовании процедур короче и понятнее, процедуры можно вызывать из разных мест программы (в противном случае пришлось бы повторять в тексте программы одинаковые последовательности действий несколько раз).
Те действия, которые входят в процедуру, записываются до начала основной программы в следующем виде:
 program ...
 const ...
 type ...
 var ...
 procedure MyProc;
 begin {действия}
 end;
 begin {основная программа}
 end.
 Рассмотрим пример нахождения максимума из трёх чисел:
Program Max1;
var a,b,c,m: integer;
begin
write('Введите a: '); readln(a);
write('Введите b: '); readln(b);
write('Введите c: '); readln(c);
if a>b then m:=a else m:=b;
if c>m then m:=c;
writeln('Максимум = ',m);
readln;
end. {Перепишем его с использованием процедуры:}
program Max2;
var a,b,c,m: integer;
procedure FindMax;
begin
if a>b then m:=a else m:=b;
if c>m then m:=c;
end;
begin
write('Введите a: '); readln(a);
write('Введите b: '); readln(b);
 write('Введите c: '); readln(c);
FindMax;
writeln('Максимум = ',m);
readln;
end.
Этот вариант можно улучшить. Пока наша процедура может искать минимум только среди значений конкретных переменных a, b и c. Заставим её искать минимум среди любых трёх целых чисел и помещать результат в нужную нам переменную, а не всегда в m. Чтобы была видна польза от такой процедуры, рассмотрим пример программы для поиска максимума среди чисел a+b, b+c и a+c:
Program Max3;
var a,b,c,m: integer;
procedure FindMax(n1,n2,n3: integer; var max: integer);
begin
if n1>n2 then max:=n1 else max:=n2;
if n3>max then max:=n3;
end;
begin
write ('Введите a: '); readln(a);
write ('Введите b: '); readln(b);
write ('Введите c: '); readln(c);
FindMax (a+b,b+c,a+c,m);
writeln ('Максимум из сумм = ',m);
readln;
end.
В скобках после имени процедуры (в её описании) записаны так называемые параметры. Эта запись обозначает, что внутри процедуры можно использовать целые числа, обозначенные n1, n2 и n3, а также заносить значения в переменную типа integer, которая внутри процедуры называется max (а реально во время работы программы все действия производятся над переменной m). Параметры, в которых хранятся числа (n1,n2,n3) называются параметрами-значениями; а те, которые обозначают переменные (max) (параметрами-переменными, перед ними в описании ставится слово var. Параметры, на которые имеются ссылки внутри процедуры (n1, n2, n3, max), называются формальными, а те, которые реально используются при вызове (a+b, b+c, a+c, m) — фактическими.
Процедуры последнего вида оказываются достаточно удобными. Можно один раз написать такую процедуру, убедиться в её работоспособности и использовать в других программах. Примерами таких процедур являются процедуры для работы со строками, встроенные в Турбо Паскаль.
В нашем примере можно переписать программу и по-другому. Максимум из трёх чисел определяется по ним однозначно, или, говоря математическим языком, является функцией этих трёх чисел. Понятие функции есть также и в Паскале. Рассмотрим такую программу:
Program Max4;
var a,b,c,m: integer;
function Max(n1,n2,n3: integer) : integer;
var m: integer;
begin
if n1>n2 then m:=n1 else m:=n2;
if n3>m then m:=n3;
Max:=m;
end;
begin
write ('Введите a: '); readln(a);
write ('Введите b: '); readln(b);
write ('Введите c: '); readln(c);
writeln ('Максимум = ',Max(a+b,b+c,a+c));
readln;
end.
Нам уже известно как вызывать функцию из программы (например sqrt, sin и т. п.). Рассмотрим описание функции. Оно очень похоже на описание процедур, но есть два отличия:
1. После имени функции и списка параметров (если есть) через двоеточиезаписывается тип значения функции (возможны не только числовые типы, но и логические, строковые, символьные);
2. Среди операторов в теле функции наиболее важными являются операторы присваивания значения функции (в нашем случае это строчка Max:=m;).
В записанной выше функции используется так называемая локальная переменная m, то есть переменная, которая «видна» только нашей функции, а другие процедуры и функции, а также главная программа её «не видят». Кроме локальных переменных в Турбо Паскале можно определять локальные константы и типы.
Приведём другие примеры процедур и функций.
1.                Напишем на Паскале функцию [pic].
function Cube(x: real): real;
begin
Cube:=x*x*x;
end;
2. Вычисление площади треугольника через длины сторон. Здесь будет
использована формула Герона: [pic], где p (полупериметр треугольника,
a, b, c (длины сторон).
function Square(a,b,c: real): real;
var p: real;
begin
p:=(a+b+c)/2;
Square:=sqrt(p*(p-a)*(p-b)*(p-c));
end;
3. Процедура для решения квадратного уравнения. Будем передавать этой процедуре коэффициенты уравнения, а результаты своей работы она будет выдавать в трёх параметрах-переменных. Через первую, логического типа, процедура сообщит, есть ли вещественные корни, а еще в двух она выдаст сами эти корни (если корней нет, то на эти две переменные пользователь нашей процедуры может не обращать внимания).
Procedure SqEquation(a,b,c: real; var RootsExist: boolean; var x1,x2: real);
var d: real;
begin
d:=sqr(b)-4*a*c;
if d>=0 then begin
  RootsExist:=true;
  x1:=(-b+sqrt(d))/(2*a);
  x2:=(-b-sqrt(d))/(2*a);
 end
  else RootsExist:=false;
 end;
Можно вместо процедуры написать и функцию, по логическому значению которой мы определяем, есть ли корни, а сами корни передаются также как и в процедуре:
Function EqHasRoots(a,b,c: real; var x1,x2: real) : boolean;
var d: real;
begin
d:=sqr(b)-4*a*c;
if d>=0 then
begin
EqHasRoots:=true;
x1:=(-b+sqrt(d))/(2*a);
x2:=(-b-sqrt(d))/(2*a);
end
else EqHasRoots:=false;
end;
Использовать такую функцию даже проще чем последнюю процедуру:
 if EqHasRoots(1,2,1,r1,r2) then writeln(r1,' ',r2) else writeln('Нет корней').
ГЛАВА II. ПОСТАНОВЛЕНИЕ И РЕШЕНИЕ ЗАДАЧ МЕХАНИКИ В СРЕДЕ СИСТЕМЫ ПАСКАЛЬ
Процесс решения задач на компьютере – это совместная деятельность человека и ЭВМ. Этот процесс можно представить виде нескольких последовательных этапов. На долю человека приходятся этапы, связанные с творческой деятельностью – постановкой, алгоритмизацией, программированием задач анализом результатов, а на долю компьютера - этапы обработки информации с соответствии с разработанным алгоритмом.
Первый этап – постановка задачи. На этом этапе участвует человек, хорошо представляющий предметную область задачи. Он должен чётко определить цель задачи, дать словесное описание содержания задачи и предложить общий подход к её решению. Для вычисления суммы двух целых чисел человек, знающий, как складываются числа, может описать задачу следующим образом: ввести два целых числа, сложить их и вывести сумму в качестве результата решения задачи.
Второй этап – математическое и информационное моделирование. Цель этого этапа – создать такую математическую модель решаемой задачи, которая может быть реализована в компьютере. Существует целый ряд задач, где математическая постановка сводится к простому перечислению формул и логических условий. Этот этап тесно связан с первым этапом, и его можно отдельно не рассматривать, однако возможно, что для полученной модели известны несколько методов решения, и тогда предстоит выбрать лучший. Для вышеописанной задачи данный этап сведётся к следующему: введённые в компьютер числа запомним в памяти под именами А и В, затем вычислим значение этих чисел по формуле А+В, и результат запомним в памяти под именем Summa.
Третий этап – алгоритмизация задачи. На основе математическогоописания необходимо разработать алгоритм решения.
Четвёртый этап – программирование. Программой называется план действий, подлежащий выполнению некоторым исполнителем, в качестве которого может выступать компьютер. Составление программы обеспечивает возможность выполнение алгоритма и соответственно поставленной задачи исполнителем – компьютером. Во многих задачах при программирование на алгоритмическом языке часто пользуются заменой блока алгоритма на один или несколько операторов, введением новых блоков, замена одних блоков на другими.
Пятый этап – ввод программы и исходных данных в ЭВМ. Программа и исходные данные вводятся в ЭВМ с клавиатуры с помощью редакторов текстов, и для постоянного хранения осуществляется их запись на гибкий или жёсткий магнитный диск.
Шестой этап – тестирование и отладка программы. На этом этапе происходит исполнение алгоритма с помощью ЭВМ, поиск и исключение ошибок. При этом программисту приходится выполнять рутинную работу по проверке работы программы, поиску и исключению ошибок, и поэтому для сложных программ этот этап часто требует, гораздо больше времени и сил, чем написание первоначального текста программы.
Отладка программы – сложный и нестандартный процесс. Исходный план отладки заключается в том, чтобы оттестировать программу на контрольных примерах.
Контрольные примеры стремятся выбрать так, чтобы при работе с ними программа прошла все основные пути блок – схемы алгоритма, поскольку на каждом из путей могут быть свои ошибки, а детализация плана зависит от того, как поведёт себя программа на этих примерах: на одном может зациклиться (т.е. бесконечно повторять одно и то же действие); на другом – дать явно неверный или бессмысленный результат и т.д. Сложные программы отлаживаются отдельными фрагментами.
Для повышения качества выполнения этого этапа используются специальные программы – отладчики, которые позволяют исполнить программу «по шагам» с наблюдением за изменением значений переменных, выражений и других объектов программы, с отслеживанием выполняемых операторов.
Седьмой этап – исполнение отлаженной программы и анализ результатов. На этом этапе программист запускает программу и задаёт исходные данные, требуемые по условию задачи.
Полученные в результате решения выходные данные анализируются постановщиком задачи, и на основе этого анализа вырабатываются соответствующие решения, рекомендации, выводы. Например, если при решение задачи на компьютере результат сложения двух чисел 2 и 3 будет 4, то следует сделать вывод о том, что надо изменить алгоритм и программу.
Возможно, что по итогам анализа результатов потребуется пересмотр самого подхода к решению задачи и возврат к первому этапу для повторного выполнения всех этапов с учётом приобретённого опыта. Таким образом, в процессе создания программы некоторые этапы будут повторяться до тех пор, пока мы получи алгоритм и программу, удовлетворяющие показанным выше свойствам.

2.1. ЗАДАЧИ СТАТИКИ, РЕШАЕМЫЕ С ПОМОЩЬЮ ЯЗЫКА ПАСКАЛЬ
Основной задачей статики является изучение методов замены различных систем сил, действующих на абсолютно твердое тело, простейшими системами, оказывающими на тело такое же действие, как и исходная система.
Выяснение условий взаимной уравновешенности системы сил является одной из основных задач статики.
На основе изложенной в первой главе курсовой работы алгоритм конструкции языка программирования Паскаль составим и решим ряд задач по прикладной механике.
Сформулируем задачу по статике первому разделу прикладной механики.
Задача. Найти центр тяжести тонкого круглого однородного стержня изогнутого по дуге окружности. Размеры стержня указаны на рисунке.
Геометрическая модель решения задачи по статике.
Решение:
Плоскость, в которой лежит окружность радиуса R, является плоскостью симметрии тела. Мы примем ее за координатную плоскость хОу. Тогда будем иметь z_c=0. Кроме того того, тело имеет ось симметрии, расположенную в плоскости и направленную по биссектрисе угла 2α.

Рис. 1. Геометрическая модель тонкого круглого однородного стержня изогнутого по дуге окружности
Принимая эту ось ось за ось абсцисс, заключаем, что y_c=0. Выбрав начало координат в центре окружности радиуса R, вычислим абсциссу центра тяжести тела.
Выделим элементарный цилиндр с длиной образующей dl. Его объем равен
dv=πr2dl=πr2Rвφ,
 а абсцисса его центра тяжести равна
x=Rcosφ
При решении задач на равновесие твердого тела при наличии сил трения следует выполнить:
1. Выделить твердое тело, равновесие которого надо рассмотреть для отыскания неизвестных величин.
2. Изобразить активные силы.
3. Если твердое тело несвободно, то применив закон освобождаемости от связей, приложить к нему соответствующие реакции связей.
4. Рассмотреть равновесие данного несвободного твердого тела. как тела свободного, находящегося под действием активных сил и реакций связей.
При этом следует реакцию шероховатой поверхности представить двумя составляющими – нормальной реакцией и силой трения, или же двумя составляющими – нормальной реакцией и силой трения, или же, не раскладывая эту реакцию на составляющие, направить ее под углом трения к нормали к поверхности (при максимальной силе трения).
5. Сопоставить число неизвестных величин и число независимых уравнений равновесия, которые должны быть равны для статически определимых задач; при этом к уравнениям равновесия твердого тела следует добавить зависимость силы трения от нормального давления;
6. Выбрать систему координат.
7. Составить систему уравнений равновесия для сил, приложенных к твердому телу или к системе твердых тел.
8. Решив систему уравнений равновесия, определить искомые величины.
Таким образом, мы пришли к результату, выраженному формулой (2).  Сопоставляя оба решения, мы видим, что в первом случае мы применили общий метод составления уравнений равновесия для твердого тела, находящегося под действием произвольной плоской системы сил, не учитывая особенностей данной задачи. Достоинство общих методов и заключается в том, что они ведут к цели, несмотря на различия в условиях задач.
Иногда такой путь не является самым простым и коротким. На примере второго способа решения мы видим, что при учете особенностей данной задачи удалось составить меньшее число уравнений равновесия, которые проще и скорее привели к цели.
На основе разработанного алгоритма решения задачи по статике составим Паскаль-программу.
Program Statika;
Var
x, y, a, Pmin, Pmax:Real;
R:Integer;
Begin
Writeln('vvedite ves sterchnya');
Readln(dv);
Writeln('vvedite dliny sterchnya');
Rreadln(dl);
Writeln('vvedite ugol');
Readln(φ); {φ=60}
Pmin:=(R*(((cos(φ)*3.14/180)/cos(φ)*3.14/180)+y)); {minimalnaya velichina gruza}
Pmax:=(R*(((cos(a)*3.14/180)/cos(φ)*3.14/180)-y)); {maximalnaya velichina gruza}
{pri cos(φ)<y sila xmax ne suschestvuet}
Begin
If xmax<0 then x:=xmin+xmax;
If xmax>0 then x:=Pmin-xmax;
End;
Writeln('xmin=',xmin:8:6);
Writeln('xmax=',xmax:8:6);
Writeln('x=',x:8:6);
Readln;
End.
2.2. ЗАДАЧИ КИНЕМАТИКИ, РЕШАЕМЫЕ ПОСРЕДСТВОМ ЯЗЫКА ПАСКАЛЬ
Скорости точек плоской фигуры могут быть определены аналитическими , графическими или же графоаналитическими методами.
Аналитический метод. При аналитическом методе должны быть заданы уравнения движения плоской фигуры (рис.2)
Хo₁=f ₁(t) , Yо₁ =f ₂(t) , φ = f₃ (t). (1*)
Проекции скорости точки М на неподвижные оси координат определяется равенствами:
V_x=Vо₁Х-W _z(Y-Yo₁)   (2*)
V_y=Vо₁Y + W_z (Х-Хo₁)   (3*)
В этих формулах V_x , V_y – искомые проекции скорости точки М на неподвижные оси координат; Vо₁x = Хo₁ , Vо₁y = Yo₁-проекции скорости полюса, начала подвижной системы координат ХY на неподвижные оси координат ; W_z =φ -проекция угловой скорости на ось Z , перпендикулярную к плоскости движения ;ХУ координаты точки М в неподвижной системе координат ; Хо₁ ,Yо₁ – координаты полюса О₁ в неподвижной системе осей. Определение координат Х ,Y точки М , по заданным уравнениям движения плоской фигуры (1*) производится по формулам:
Х=Хо₁+Х₁ cosφ – Y₁sin φ
Y= Yо₁+ Х₁ sin φ +Y₁ cos φ
Проекции скорости точки М на неподвижные оси координат находятся по формулам:
Vx₁ =Vo₁ x cos φ + Vo₁ у sin φ – Wzy₁ (4*)
Vу ₁= -Vo₁ x sin φ + Vo₁ у сos φ – Wz х₁ (5*)
В этих формулах Vx , Vу- искомые проекции скорости точки М на оси х, у подвижной системы координат , жестко связанной с плоской фигурой ; х у – координаты точки М в подвижной системе осей , остальные величины имеют то же значение , что и в уравнениях (2*) , (3*).
Величины скорости точки М по известным проекциям определяются формулой:
V= √Vx ²+ Vу² =√ Vx₁² + Vу₁²    (6*)
Направляющие косинусы даются равенствами:
cos (V,X)= Vx/V , cos (V,У)= Vy/V    (7*)
cos (V,X)= Vx/V , cos (V,У)= Vy/V    (8*)
Графоаналитические методы. Первый графоаналитический способ определения скоростей точек плоской фигуры основан на формуле распределения скоростей (рис.2).
 
Рис. 2. Геометрическая модель плоской фигуры

V=Vo₁+W r , (9*)
в этой формуле
V – искомая скорости точки М;
Vo₁ - скорость полюса О,
W - угловая скорость плоской фигуры;
r - радиус-вектор , проведенный из полюса О в Рис. 3 точку М.        
Таким образом, зная скорость какой-либо точки плоской фигуры, выбираем эту точку за полюс. Далее откладываем от точки М, скорость которой подлежит определению, вектор, равный скорости полюса, и вектор W r₁, направлен перпендикулярно к r₁, и равный по величине W r₁.Векторная сумма этих слагаемых и дает искомую скорость точки М, Если скорость точки М известна по направлению, то можно не знать величины вращательной скорости W r₁, так как и эта скорость, и искомая скорость точки М определяется пересечением прямой, совпадающей с направлением скорости точки М, и прямой, перпендикулярной к линии О М, проведенной из конца вектора Vо, отложенного из точки М.