Program Prim16;

Label NAH,KON;

Var i,n:integer; a,b,x,h,spred,spos,e:real;

BEGIN writeln('введите точность е и границы a, b');

readln(e,a,b); spred:=9.9e+10; h:=0; n:=10;

NAH: spos:=0; h:=(b-a)/n; x:=a;

for i:=1 to n do

Begin spos:=spos+(abs(cos(x))+abs(cos(x+h)))/2*h;

x:=x+h; end;

if abs(spos-spred)<=e then Begin

writeln('s=',spos,' n=',n); goto KON; end

else spred:=spos; n:=n*10; x:=a; goto nah;

KON: readln; END.

Работа программы: for i: = i to n do, в первый раз оператор

Spоs: = spos+(abs(cos(x))+abs(cos(x+h)))/2h

посчитает значение интеграла для 10 точек разбиения. Затем if сравнит полученное значение spos с 9.9Е+10. Конечно, разница между этими величинами не будет меньше е, тогда мы забудем число 9.9Е+10, так как присвоим spred: = spоs, чтобы при следующем выполнении if сравнивать предыдущее и последующее значения интеграла. После этого увеличим количество точек разбиения n: = n10 и вернемся на начало вычисления spos, т.е. интеграла для 100 интервалов goto nach. После нового вычисления spos сравним 100 интервалов для 10 интервалов spred. Если разность между ними не меньше Е, то забудем значение s для 10 интервалов и занесем в spred значение для 100 интервалов. Затем вычислим значение интеграла для разбиения 1000 и результат занесем в spos, сравним spred и spos и т.д.

4.2. Оператор repeat. Общий вид

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

repeat

оператор;

оператор;

- - - - - - - -

оператор until булевское выражение;

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

Явного перебора параметров в repeat не предусмотрено, поэтому изменение параметров осуществляется в теле цикла. Здесь же мы должны позаботиться , чтобы рано или поздно булевское выражение стало истиной.

Замечания: 1.Тело оператора repeat выполняется по меньшей мере один раз. Оператор repeat еще называют циклом с послеусловием.

2. Перед until ';' не ставится.

Пример: найти сумму четных чисел в интервале от 0 до 100.

Program Prim17;

Var i,s:integer;

BEGIN i:=0; s:=0;

repeat

i:=i+2; s:=s+i

until i>100;

writeln('s=',s);

readln; END.

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

Пусть U = 220, R = 100, L = 0.57, С = 3.210-3, Fначальное=10; F будем менять с шагом 0.5. Печатать все результаты. Результаты, когда i3, нас не интересуют.

Program Prim18;

Var i,r,f,l,c,u:real;

BEGIN writeln(' введите значения u r l c');

readln(u,r,l,c);

f:=50;

repeat i:=u/sqrt(sqr(r)+sqr(2*pi*f*l-1/(2*pi*f*c)));

f:=f-1;

writeln('f=',f,' i=',i)

until i>3;

readln; END.

4.3. Оператор While

Оператор While цикла с предусловием.

While - булевское выражение; do - тело цикла.

Работа оператора. Вначале вычисляется булевское выражение, и если оно истинно, то выполняется тело цикла; если оно ложно, то происходит выход из цикла.

Тело цикла - один оператор, как правило, составной. Мы должны позаботиться о том, чтобы булевское выражение в теле цикла на каком-то этапе стало ложным, иначе цикл никогда не закончится. Цикл можно сделать умышленно бесконечным, написав: while true do оператор;

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

Пример: найти сумму четных чисел в интервале от 0 до 100.

Program Prim19;

Var i,s:integer;

BEGIN i:=0; s:=0;

while i<100 do

Begin i:=i+2; s:=s+i; end;

writeln('s=',s);

readln; END.

Пример: в цепи переменного тока найти ток в зависимости от его частоты.

Program Prim20;

Var i,r,f,l,c,u:real;

BEGIN writeln('введите значения u,r,l,c');

readln(u,r,l,c);

f:=50;

while i<3 do

Begin i:=u/sqrt(sqr(r)+sqr(2*pi*f*l-1/(2*pi*f*c)));

f:=f-1;

writeln('f=',f,' i=',i); end;

writeln('i>3, i=',i);

readln; END.

4.4. Вложенные циклы

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

Program Prim21;

Var

i,j:integer;

BEGIN

for i:=1 to 5 do

Begin writeln;

for j:=20 to 23 do

write('i=',i,' j=',j);

end;

readln; END.

Для цикла for i:=1 to 5 do телом цикла является

begin for j:=20 to 23 do

write(' i= ', i, ' , j = ', j);

writeln;

end;

Назовем этот цикл внешним. Кроме того, имеется внутренний цикл

for j: = 20 to 23 do с телом write (' i = ', i , j =', j);

Работа программы. Вначале машина встречает внешний цикл и начинает его выполнять: присваивает i=l, затем переходит к его телу, а здесь встречает внутренний цикл и присваивает j значение 20, после чего выполняет тело внутреннего цикла, т.е. выводит на экран i=l, j=20. Так как внутренний цикл еще не окончен, то машина продолжает его выполнять, т.е. присваивает j значение 21 и добавляет к уже выведенной строке i=l, j=21.

Заметим, что оператор write отличается от оператора writeln тем, что он не начинает вывод с новой строки, а продолжает писать в той же строке, т.е. после второго выполнения внутреннего цикла на экране появится

i= 1, j=20 i= 1, j=21.

Машина продолжит выполнение внутреннего цикла, и, когда он закончится (выполнится для j = 20.21.22.23), на экране будет строка

i = 1 j = 20 i =l j = 21 i = 1 j = 22 i = 1 j = 23.

Внутренний цикл закончится, однако тело внешнего цикла еще не закончилось, поэтому выполняется оператор writeln, который переводит курсор на новую строку. После этого тело внешнего цикла закончится, но сам цикл отработал только для i = 1. Поэтому внешний цикл продолжит работу, присвоив i: =2 и вновь начав выполнение своего тела. Встретив внутренний цикл j:=1, на экран с новой строки выведется: i=2, j=20, затем j:=2 и к этой строке добавится i=2, j=21 и т.д., пока не закончится внутренний цикл.

Таким образом, внешний цикл, изменяя i от 1 до 5, заставит каждый раз выполняться полностью внутренний цикл, и в результате работы программы на экране появится:

i=l, j=20 i=1, j=21 i=1, j=22 i=1, j=23

i=2, j=20 i=2, j=21 i=2, j=22 i=2, j=23

i=3, j=20 i=3, j=21 i=3, j=22 i=3, j=23

i=4, j=20 i=4, j=21 i=4, j=22 i=4, j=23

i=5, j=20 i=5, j=21 i=5, j=22 i=5, j=23

Вкладывать циклы друг в друга можно любое количество раз, необходимо лишь помнить, что количество выполнений самого внутреннего тела цикла при этом будет расти в геометрической прогрессии. Так, например,

for i:=l to 100 do

for j:=l to 100 do

for k:=l to 100 do

writeln (i, j, k);

дает столбик цифр:

111

112

113

114

- - - - -

121

122

123

124

- - - - -

211

212

213

- - - - -

100100100,

что составляет 1000000 строчек.

Пример: найти rez = f (х1) + f (х2 )+.. .+f (x6),

где

f(x) считать с точностью не менее e=0.01;

х1=0.1, затем xn=xn-l+0.2, пока х не станет равным 1.1.

Нам нужно вычислить rez. Поскольку это будет сумма, то вначале положим rez=0, затем вычислим f(х1) с нужной точностью и добавим к rez, и т.д., то есть:

Rez : = 0 ; x:=0.l;

for i:=l to 6 do

Begin Rez:=Rez+f(x);

x:=x+0.2;

end;

Теперь в данную программу нужно "вставить" вычисленные f(x) с необходимой точностью. Для этого найдем сумму, составляющую f(x) для n элементов, затем - для n+l элемента, сравним их по модулю и, когда разность между ними будет меньше Е, сумму для n+l элемента ряда примем за более точную и добавим к Rez. При вычислении f(x) количество членов ряда, которые нам придется суммировать, не известны, поэтому придется применять цикл типа repeat или while. Кроме того, в элементы ряда входит 2n! Факториал подсчитывается по схеме 1! = 1, 21 = 12; з! =123 и т.д., т.е. например, 8! = 12345678. Далее, при подсчете следующего значения ряда, можно величину 2n! найти по схеме: fak: = fak(n-l)n. Ряд у нас знакопеременный, т.е. меняется '+', '-' перед каждым членом ряда. Меняем знак с помощью схемы znak: = znak(-1). Если исходный знак = +l, то в ячейке znak будет храниться то +l, то -1.

С учетом сказанного выше f(x) с нужной точностью вычисляется:

fxpred: = 0; fxpos: =l, n: = 2; znak: = 1; fak: = 1;

while Abs(fxpos - fxpred) > = 0.01 do

Begin fxpred: = fxpos: znak: = znak(-1); fak: = fak(n-l)n;

fxpos: = fxpos+znakexp(nin (x))/fak;

n: = n+2;

end;

Соединив оба фрагмента программы и снабдив их описаниями, получим готовую программу:

Program Prim22;

Var n,fak,i,znak:longint;

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22