Числовые последовательности
Начнем с определения последовательности. Определений числовой последовательности дается много, причем самых разных и достаточно понятных, но, по моим соображениям, самое лучшее с точки зрения и математической строгости и доступности дается в книге: "Курс дифференциального и интегрального исчисления", т. 1 Г.М. Фихтенгольца. Я привожу его с незначительными изменениями.
Представим себе натуральный ряд:
1, 2, 3, ..., n, ..., n', ...,
в котором числа расположены в порядке возрастания, так что большее число n' следует за меньшим числом n (или меньшее n предшествует большему числу n'). Если теперь заменить в этом ряде, по какому-нибудь закону каждое натуральное число n некоторым вещественным числом xn , то получится числовая последовательность:
x1, x2, x3, ..., xn, ..., xn', ...,
члены или элементы которой xn занумерованы всеми натуральными числами и расположены в порядке возрастания номеров. При n'>n, член xn' следует за членом xn (xn предшествует xn' ), независимо от того, будет ли само число xn' больше, меньше или даже равно числу xn.
В школьном курсе математики вы уже знакомились с последовательностями вида
или вида
В связи с определением длины окружности обычно рассматривается переменный периметр правильного вписанного в окружность многоугольника, получаемого из шестиугольника последовательным удвоением числа сторон; таким образом, получается следующая последовательность:
Упомянем еще о десятичном приближении (скажем, по недостатку) к
Иногда последовательность задается тем, что указывается непосредственно
выражение для xn; так, в случае арифметической или геометрической прогрессии имеем, соответственно,
В других случаях нам может быть неизвестно выражение для общего члена xn последовательности.
Тем не менее, последовательность считается заданной, если мы владеем правилом, по которому может быть вычислен любой ее член, лишь только известен его номер.
Поэтому-то, зная правило для приближенного вычисления корней, мы можем считать заданной всю последовательность десятичных приближений к
Если последовательность - в указанном смысле - задана, то этим не только охарактеризовано все множество принимаемых ею значений в целом, но и определен порядок, в котором эти значения принимаются; каждому номеру отвечает свое значение элемента последовательности, и из двух значений то считается следующим, номер которого больше.
Еще подчеркнем, что значения элементов последовательности не должны быть обязательно различными. Например, если задать последовательность одной из формул:
то соответствующие последовательности будут:
В первом
случае мы имеем просто постоянную величину, всё "множество" принимаемых ею значений сводится к одному.
Во втором
- это множество состоит из двух значений, 1 или -1, принимаемых поочередно. Наконец, в третьем случае множество значений бесконечно, но это не мешает значениям элементов через одно равняться 0; и мы считаем, что значение 0 на пятом месте следует не только за 1 на втором месте, но и за значением 0 на первом месте.
Еще один способ задания последовательности - это рекуррентная формула. Вспомним, что это такое.
Формулу, выражающую любой член последовательности, начиная с некоторого, через предыдущие (один или несколько), называют рекуррентной
(от латинского слова recurro - возвращаться).
Подводя итог вышеизложенного можно назвать три основных способа задания последовательности.
1. Аналитический
- последовательность задается формулой общего (или n-го) члена.
2. Рекуррентный
- любой член последовательности, начиная с некоторого, выражается через предшествующие члены. При этом способе задания последовательности указывают ее первый член или несколько начальных членов и формулу, позволяющую определить любой член последовательности по известным предшествующим членам.
3. Словесный
- задание последовательности описанием.
Надо сразу заметить, что для составления программ чаще нам придется использовать рекуррентное соотношение. Покажем это на примере.
Пример 1. Составить программу вывода на экран членов последовательности, заданной следующей формулой:
Для составления программы необходимо перейти от формулы n-го члена, которым задана последовательность к рекуррентному соотношению, связывающему предыдущий член с последующим и указать начальное значение для первого или "нулевого" элемента. Как это сделать? Оказывается очень просто!
1. Запишем, чему будет равен член последовательности предыдущий к n - му, т. е. n-1 - й элемент последовательности:
2. Теперь разделим n - й элемент на n-1 - й, получим:
3. Отсюда выразим, чему будет равен n-й член:
4. Найдем начальное значение
Процедуру можно построить из одного цикла с параметром, в котором каждый раз при выполнении цикла предыдущее значение будет умножаться на 10 и делится на значение переменной цикла, которая обозначена n.
Procedure Create_succession(k : integer);
var
n : integer;
a : real;
begin
a := 1;
writeln('Искомая последовательность');
for n := 1 to k do
begin
a := a*10/n;
write(a:6:6, ' ')
end;
writeln
end;
Программа
Program Problem1; {Вывод членов последовательности}
uses WinCrt;
var
k : integer;
{---------------------------------------------------------------------------------------}
Procedure Create_succession(k : integer);
var
n : integer;
a : real;
begin
a := 1;
writeln('Искомая последовательность');
for n := 1 to k do
begin
a := a*10/n;
write(a:6:6, ' ')
end;
writeln
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите число элементов '); readln(k);
Create_succession(k);
end.
Пример 2. Составим программу вывода на экран членов последовательности, описываемой словесно, в частности, десятичных приближений числа
Вот здесь дело обстоит сложнее. Закон, по которому строится последовательность указан словесно. Надо от словесного задания правила перейти к рекуррентной формуле.
А есть ли формула для вычисления квадратных корней? Оказывается есть и достаточно простая.
Рассмотрим бесконечную последовательность x1, x2, x3, ..., образованную по следующему закону:
Оказывается, что члены этой последовательности с увеличением номера i всё меньше и меньше отличается от
Напомним, что
Мы можем, используя данное рекуррентное соотношение, составить процедуру и программу
вычисления квадратных корней для любого действительного подкоренного выражения, а не только 2.
Program Problem2;
uses WinCrt;
var
n : integer;
u : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root(n : integer; u : real);
var
i : integer;
x : real;
begin
writeln('Десятичные приближ. с недост. кв. корня из ', u);
x := (u + 1)/2;
for i := 1 to n do
begin
x := (1/2)*(x + u/x);
write(x:3:i, ' ')
end;
writeln
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Введите число членов последовательн. '); readln(n);
Square_root(n, u);
end.
Вычислим приближенное значение квадратного корня из заданного числа с указанной точностью eps. Теперь нам не надо выводить на экран все члены последовательности, а выдать только одно значение удовлетворяющее указанной точности.
Например, поставлена задача получить квадратный корень из 2 с точностью до 0.01. На экран должно быть выдано значение этого корня (причем совсем не обязательно, чтобы в его записи было два знака после запятой, их может быть больше, но мы будем заведомо знать, что знаки после сотых долей не являются точными).
Такие программы
можно составить двумя способами.
Способ первый состоит в том, что цикл будет продолжаться до тех пор, пока разность между квадратом получаемого результата и подкоренным выражением по абсолютной величине не станет меньше или равна указанной точности eps. Тогда цикл заканчивается и выдается результат.
1-й способ
Program
Problem2a;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root1(eps, u : real; var x : real);
begin
x := (u + 1)/2;
repeat
x := (1/2)*(x + u/x)
until abs(x*x - u) <= eps
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root1(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:12:12);
writeln(' с точностью до ', eps:3:12)
end.
Во втором способе вычисляются два члена последовательности и их разность по абсолютной величине сравнивается с заданной точностью.
Как только эта разность станет равна или меньше указанной точности eps цикл заканчивается.
2-й способ
Program Problem2b;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root2(eps, u : real; var x : real);
var
x1, x2 : real;
begin
x1 := 1;
repeat
x1 := (1/2)*(x1 + u/x1);
x2 := (1/2)*(x1 + u/x1)
until abs(x2 - x1) <= eps;
x := x2
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root2(eps, u , x );
writeln('Квадратный корень из ', u, ' равен ', x:12:12);
writeln('с точностью до ', eps:3:12)
end.
Разберите содержание этих программ и выполните их на компьютере. В чем отличие этих двух способов? Какой из них вы считаете более рациональным и почему?
Измените каждую из этих программ так, чтобы на экран выдавались последовательно десятичные приближения корней с недостатком? С избытком?
Если вы внимательно разобрались в составлении и работе предыдущих программ, то могли заметить, что в программе примера 2, несмотря на то, что математически последовательность задана формулой n-го члена, используется рекуррентное соотношение. Указывается начальное значение a := 1, а затем каждый цикл предыдущее значение умножается на постоянный множитель:
Таким образом, при составлении программ чаще всего будет использоваться рекуррентное соотношение. Возникает закономерный вопрос. Как перейти от задания последовательности формулой n-го члена к рекуррентному соотношению?
Разберем этот процесс на частном примере.
Пример..
Пусть задана последовательность с помощью формулы n-го члена, например:
Разделим n-й член на (n-1)-й, получим:
Отсюда легко получить рекуррентную формулу:
Одной формулы недостаточно, еще необходимо задать некоторые начальные значения, первые члены последовательности, желательно нулевой член.
Получаем:
Итак, если последовательность задана формулой n-го члена, тогда, чтобы задать ее рекуррентной формулой, необходимо найти частное от деления n-го члена на (n - 1)-й, а затем умножить (n - 1)-й член на частное. Это произведение будет равно n-му члену и мы получаем нужную формулу. К ней необходимо добавить значение некоторых первых членов и, таким образом, последовательность будет задана. Коротко этот процесс можно записать так:
После выполнения программы вы, конечно, обратили внимание на то, что независимо от того какую точность вы указываете значение результата будут выдаваться с 12-ю знаками после запятой (такой формат задан в программе). И нам трудно определить сколько десятичных знаков являются верными.
Было бы очень удобно, указав точность, получать в результате только требуемое количество десятичных знаков, например, указав 0.001, мы получали бы в результате 3 знака после запятой и не более.
Это можно сделать с помощью следующей функции:
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
Ее работа проста. Введенное значение точности (eps) последовательно умножается на 10 до тех пор, пока ее значение не станет больше 1.
Например, для значения eps = 0.001 процесс определения порядка будет проходить так:
Переменная k подсчитывает число выполняемых циклов. Но число циклов будет на 1 больше, чем количество знаков после запятой. Почему? Да потому, что цикл выполняется до тех пор пока, пока значение eps станет больше 1. Это сделано из тех соображений, что значение eps никогда не станет точно равно 1, ибо для этой переменной установлен вещественный тип real, а это значит, что eps не будет равно целому числу, хотя в примере кажется, что
Фактическое значение в этом случае может выражаться числом 0.99999999... . Чтобы устранить неудобства, первоначальному значению k задано значение -1, а останов цикла выполняется после eps > 1.
Добавляя эту функцию в программу, легко использовать ее для вывода результата с требуемым числом десятичных знаков.
Тогда, две вышеприведенные программы могут быть построены так:
Program Problem2a;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{---------------------------------------------------------------------------------------}
Procedure Square_root(eps, u : real; var x : real);
begin
x := (u + 1)/2;
repeat
x := (1/2)*(x + u/x)
until abs(x*x - u) <= eps
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Program Problem2b;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{---------------------------------------------------------------------------------------}
Procedure Square_root(eps, u : real; var x : real);
var
x1, x2 : real;
begin
x1 := 1;
repeat
x1 := (1/2)*(x1 + u/x1);
x2 := (1/2)*(x1 + u/x1)
until abs(x2 - x1) <= eps;
x := x2
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 1
1. Составьте программы вывода на экран членов последовательности, задаваемых следующими способами:
1)
3) последовательность состоит из десятичных приближений с избытком частного
Пример 3. Рассмотрим бесконечную последовательность x1, x2,..., образованную по следующему закону:
где u - данное неотрицательное действительное число, n - натуральное число.
Эта последовательность позволяет получить сколь угодно точные приближения числа
{ Вычисление корня с любым натур. показат. действит. числа }
Program Problem3;
uses WinCrt;
var
u, n, eps, x : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure Root(u, n, eps : real; var
x : real);
var
x1, x2, xn : real;
i : integer;
begin
x1 := (u + n - 1)/2;
repeat
xn := 1;
for i := 1 to trunc(n) - 1 do
xn := xn*x1;
x1 := ((n - 1)*x1 + u/xn)/n;
x2 := ((n - 1)*x1 + u/xn)/n
until abs(x1 - x2) <= eps;
x := x2
end;
{--------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Введите показатель корня '); readln(n);
write('Введите точность вычисления '); readln(eps);
Root(u, n, eps, x);
writeln('Значение корня равно ', x:8:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Рассмотрим несколько последовательностей, заданных формулами n-го члена:
3)
4)
5)
Нам еще придется на следующем занятии иметь дело с этими последовательностями, но уже при постановке несколько иной задаче. А теперь составим программы вычисления членов последовательности, причем вычисления вести до того члена, который по абсолютной величине станет равным или меньше заданной точности. Выполним это задание для последовательностей 2-й и 4-й.
Пример 4.
Последовательность задана формулой
Вывести на экран члены последовательности до члена, меньшего заданного положительного числа eps. Желательно принять 0 < eps < 1.
Самое важное - это перейти от формулы n-го члена к рекурретному соотношению, которое впоследствии надо использовать при составлении программы.
Запишем формулу n-1 -го члена:
Разделим un
на un-1, получим:
тогда
Надо заметить, что первый член равен: u1 = x.
После этого нетрудно составить программу. Организуем цикл с предусловием "пока", пока |u| > eps. Почему для этой задачи удобно устроить именно такой цикл?
В нашем примере, в качестве начального значения берется первый элемент последовательности. Может случиться, что пользователь задал такое значение eps, что уже первый член меньше этого числа. И тогда вычислений выполнять не следует, т.е цикл не выполняется, а значит необходимо сразу проверить условие. Такое делается в цикле с предусловием. Цикл repeat ... until будет обязательно выполняться хотя бы один раз, а этого нам не нужно.
Программа
Program Problem4;
uses
WinCrt;
var
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(x, eps : real);
var
u : real;
n : integer;
begin
u := x;
n := 1;
while abs(u) > eps do
begin
n := n + 1;
write(u:6:t(eps), '; ');
u := (-1)*u*x*x/((2*n - 2)*(2*n - 1))
end;
writeln
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значения |x| <= 1 '); readln(x);
write('Задайте положит. число eps '); readln(eps);
writeln('Члены последовательности');
Create_succession(x, eps);
end.
Пример 5. Последовательность задана формулой:
где m - вещественное число, отличное от 0 и от всех натуральных чисел, при
Вывести на экран члены последовательности до члена, меньшего наперед заданного положительного числа eps, 0 < eps < 1.
Из формулы n-го члена составьте рекуррентную формулу, установите каким должно быть первоначальное значение, составьте программу и сравните ее с приведенной ниже программой.
Program Problem5;
uses WinCrt;
var
x, m, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(x, m, eps : real);
var
n : integer;
u : real;
begin
u := 1;
n := 1;
repeat
u := u*(m - n + 1)*x/n;
write(u:3:t(eps), ' ');
n := n + 1
until abs(u) <= eps;
writeln
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите значения x, |x| < 1 '); readln(x);
writeln('Введите вещественное положительное m, отличное от');
write('натуральных чисел '); readln(m);
write('Задайте положительное число eps '); readln(eps);
writeln('Члены последовательности');
Create_succession(x, m, eps)
end.
Задание 2
Составьте программы вывода на экран членов последовательности до члена, меньшего заданного положительного числа eps, 0 < eps < 1. Возьмите для задания примеры 1, 3, 6:
1)
3)
6)
Усложним задачи и разберем следующий пример.
Пример 6. Дано положительное число eps. Последовательность a1, a2, a3,... образована по следующему закону:
Найти первый член an последовательности, для которого выполнено условие:
Составить программу выполнения этого задания.
Алгритм
1. Содержание.
а) Переменные и их типы. Переменная i принимает целые значения:
2. Основная часть.
а) Ввод значения eps.
б) Установить первоначальные значения переменных i, ap и an:
i := 1, ap := 1, an := 1 - 1/2.
в) Цикл "пока" с условием: abs(an - ap) >= eps.
Команды в цикле. Значения i каждый раз в цикле должны увеличиваться на единицу; значения ap := 1 - 1/i; значения an := ap*(1 - 1/(i + 1)).
г) После завершения работы цикла, вывод значения an на экран. Можно вывести и номер i этого члена последовательности.
3. Конец.
Составим процедуру и программу, используя алгоритм.
Программа
Program Problem6;
uses
WinCrt;
var
i : integer;
a, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(eps : real; var i : integer; var a : real);
var
i : integer;
an, ap : real;
begin
i := 1; ap := 1; an := 1 - 1/2;
while abs(an - ap) >= eps do
begin
i := i + 1;
ap := ap*(1 - 1/i);
an := ap*(1 - 1/(i + 1))
end;
a := an
end;
{---------------------------------------------------------------------------------------}
{ Основная программа }
begin
write(' Введите любое положительное число eps '); readln(eps);
Create_succession(eps, i, a);
writeln('Искомый член последовательности ', a:6:t(eps));
writeln('Находится на ', i, '-ом месте в последовательности')
end.
Задание 3
Последовательность задана формулой:
Если Вы составили программу и выполнили ее несколько раз, то смогли убедиться в том, что для любого положительного числа eps найдется член последовательности yN, такой, что модуль разности (yN- 2) меньше eps.
Дополним программу так, чтобы она показывала, что неравенство
Но перед этим, вспомним определение предела последовательности.
Определение предела последовательности
Число A называется пределом последовательности xn, если для любого положительного числа
Последнее неравенство равносильно следующему:
Рис. 42
Какой бы малый отрезок (длиной
Точка, изображающая предел A, является как бы средоточением сгустка точек, изображающих значения членов последовательности.
Возвращаясь к примеру 5, можно сказать, что по сути дела мы показывали, что число 2 является пределом последовательности
Если эту программу немного изменить, то она станет такой.
Пример 7. Программа, показывающая, что пределом последовательности
Program Problem7;
uses
WinCrt;
var
i, n, k : longint;
eps, yn, yp : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
writeln('Введите произвольное положительное число, ');
write('можно даже очень малое '); readln(eps);
i := 1; k := -1; yn := 1;
while
abs(yn - 2) >= eps do
begin
i := i + 1; k := k*(-1);
yn := 2 + k/i
end;
writeln('Условию abs(yn-2)<', eps:1:t(eps), ' удовлетворяет');
writeln('член последовательности yn = ', yn:6:t(eps), ',');
writeln('находящийся под номером ', i); writeln;
write('Введите номер члена последовательности больше ',i,' ');
readln(n);
if
n mod 2 = 0 then yn := 2 + 1/n else yn := 2 - 1/n;
if
abs(2 - yn) < eps
then
begin
write('Неравенство abs(2 - ', yn:6:t(eps), ') < ', eps:1:t(eps));
writeln( ' выполняется ')
end
else
begin
write('Неравенство abs(2 - ', yn:6:t(eps), ') < ', eps:1:t(eps));
writeln(' не выполняется')
end
end.
Задание 4
Составьте программу, показывающую, что число 1 является пределом последовательности
Продолжим составление программ на последовательности и немного усложним задачу. Если в двух предыдущих примерах заведомо было известно число, которое является пределом последовательности, то в следующем примере надо будет определить существует ли вообще предел и если существует, тогда найти его и показать, что оно действительно является пределом заданной последовательности.
Таким образом, задача имеет две части:
1) установить существование
предела и,
2) если таковой существует, то показать чему он равен.
Перед выполнением такого задания обратимся к курсу математического анализа, в котором есть теорема, которая принадлежит чешскому математику Больцано и французскому математику Коши, ее часто называют принципом сходимости. Она выражает общий
Признак существования конечного предела последовательности
Пусть задана последовательность xn, пробегающая значения x1, x2, ..., xn, ..., xm, ... Для того, чтобы последовательность xn имела конечный предел, необходимо и достаточно, чтобы для каждого числа
между собой безгранично сближались по мере возрастания их номеров.
Этот признак допускает простую геометрическую иллюстрацию (рисунок 43).
Рис. 43
Пример 8. Выяснить имеет ли предел последовательность, заданная формулой:
Алгоритм решения основывается на признаке существования предела последовательности. Нам необходимо установить, что члены последовательности по мере увеличения номера сближаются друг с другом. Перекладывая это на язык математики, нам надо задать положительное число eps, которое может быть сколь угодно малым и найти такие два члена последовательности, разность между которыми по абсолютной величине будет меньше этого наперед заданного, может быть даже, очень малого числа eps.
Идея становится понятной. Остается продумать, как находить члены последовательности в зависимости от их номеров?
Конечно, можно составить рекуррентное соотношение, но это будет немного трудным делом чисто в математическом отношении.
Возникает другая мысль. Составить подпрограмму возведения в степень и из основной программы каждый раз обращаться к ней для вычисления степени с изменением номера n. Тем более, что опыт составления подпрограмм у нас уже есть. Мы достаточно много составляли на прошедших занятиях подпрограмм в форме процедур и функций.
Основная программа. Вначале попросим пользователя задать точность вычисления (так мы назвали число eps).
Затем задается начальное значение переменной n (n := 1). Организуется цикл с последующим условием (repeat ... until...), в котором переменной x - члену последовательности присваивается значение, вычисляющее значение функции
Проверяется условие abs(x1 - x) < eps. Как только условие выполнится, цикл закончится и в качестве значения предела последовательности мы можем брать любое из значений x или x1 и оно укажет нам значение предела последовательности с заданной точностью eps.
Если кто-нибудь из вас раньше встречался с такой последовательностью, то он сразу был уверен, что ее предел существует и равен числу e - основанию натурального логарифма.
Проверьте это, выполнив программу
Program
Problem8;
uses WinCrt;
var
n : integer; x, x1, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function s(k: integer; p : real) : real;
var
i : integer; z : real;
begin
z := 1;
for i := 1 to k do z := z*p;
s := z
end;
{----------------------------------------------------------------------------------------}
begin
write('Задайте точность '); readln(eps);
n := 1;
repeat
x := s(n, (1 + 1/n));
n := n + 1;
x1 := s(n, (1 + 1/n))
until abs(x1 - x) < eps;
writeln('Предел последовательности равен ', x1:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 5
Последовательность un принимает значения
Показать, что un
стремится к некоторому пределу при
(При составлении программы использовать в качестве подпрограммы функцию вычисления степени числа 3 с показателем n).
