4.3.2 Вычисление числа е

Задача. Вычислить значение основания натуральных логарифмов как сумму тех членов ряда

$1 + 1/1! + 1/2!+\ldots$,

которые превышают заданное число $E, 0<E<1$.

Решение. Обозначим через Сумма(K), где K$К \geq 0$, сумму
$1/0! + 1/1! + 1/2! + \ldots + 1/K!$

и рассмотрим две последовательности

$X_1,X_2,\ldots, X_L,\ldots$ и $B_1$, $B_2$,$\ldots$, $B_L$, $\ldots$,

в которых $X_i$ = $Сумма(i-1)$ и $B_i = 1/i!$ для всех $i \geq 1$. Поскольку с ростом $i$ значение $B_i$ стремится к нулю, для заданного E существует такое минимальное $L$, что $L > 1$ и $B_L\leq E$. Таким образом, для решения задачи достаточно построить последовательности X$Х_1, Х_2,\ldots, X_L$ и $B_1,B_2,\ldots,B_L$, в которых $X_L$ является ответом на вопрос задачи. Нетрудно сформулировать следующие свойства этих последовательностей:

(1) $B_1 = 1$,
(2) $X_1 = 1$,
(3) $X_K = X_{K-1} + B_{K-1}$ для всех $K > 1,$,
(4) $B_K = 1/K!$ для всех $K > 1,$
(5) $B_K > E$ для всех $K < L,$
(6) $B_L\leq E$.

Эти свойства можно использовать как правила построения элементов последовательности по схеме решения, аналогичной схеме из п. 4.3.1 и реализованной в программе Основание.

Как и Факториал, программа Основание состоит из трех частей: вычисление начального состояния памяти (строчка 1), многократное перевычисление состояния памяти в операторе цикла до тех пор, пока не будет получено желаемое конечное состояние памяти (строчки 3-17), и печать результата (строчки 19-20). Однако, в отличие от задачи из п. 4.3.1, здесь количество итераций (число $L$) заранее не известно и зависит от величины $Е$E. Поэтому в программе Основание нельзя использовать оператор цикла с параметром.

Правила 1 и 2 дают строчку 1, правила 3 и 4 в соответствии с методом, использованным в программе Факториал для вычисления факториала K!, приводят к построению цикла (строчки 4-16), а правила 5 и 6 определяют выражение в заголовке цикла.

В процессе выполнения программы переменные X и B$В$ последовательно принимают значения X$Х_1$, X$Х_2,\ldots$, X$Х_i,\ldots$,$X_L$ и $B_1$,$B_2,\ldots$, $B_i,\ldots$,$B_L$ соответственно, где $i$ -- номер итерации цикла.

module Основание;
    var X,B,E,F : real; K,M : integer;
begin
(*  1*)     read(E); X := 1; B := 1; K := 1; F := 1;
(*  2*)     (*{X=Сумма(K-1), B=1/K!, K=1}*)
(*  3*)     while B > E do
(*  4*)             (* {X=Сумма(K-1), B=1/K!>E} *)
(*  5*)             X := X+B; K := K+1;
(*  6*)             F := 1; M := 0;
(*  7*)             (* {X=Сумма(K-1), B=1/(K-1)!, E<1/(K-1)!}*)
(*  8*)             (* {F=M!, M<=K, M=0}*)
(* 9*)           while B# K do
(*10*)                     (* {F=M!, M<K, M>=0}*)
(*11*)                     M := M+1; F := F*M;
(*12*)           end;
(*13*)             (* {F=M!, M=K, M>=0}*)
(*14*)             (*{X=Сумма(K-1), B=1/K!>E}*)
(*15*)             B := 1/F
(*16*)             (*{X=Сумма(K-1), B=1/K!, E<1/(K-1)!}*)
(*17*)     end;
(*18*)     (*{X=Сумма(K-1), B=1/K!<=E, E<1/(K-1)!}*)
(*19*)     Write ('Основание натуральных логарифмов,',
(*20*)                 'найденное с точностью до',E, 'равно',X)
end Основание.

Заметим, что внутренний цикл 9-12 программы Основание можно ликвидировать, поскольку в нем для каждого нового значения $К$ повторяются все умножения, выполненные при вычислении K$К!$ для предыдущего значения $К$. Используя переменную $F$ для хранения произведения $1\cdot 2\cdot\ldots \cdot K$, можно обойтись только одним циклом (см. программу Основание$Основание2$, которая вычисляет те же последовательности значений в X и B, что и Основание, но уже базируется на следующих соотношениях:

(1) $B_1 = 1$,
(2) $X_1 = 1,$
(3) $F_1 = 1,$
(4) $F_K = F_{K-1} \cdot K$ для всех $K > 1,$
(5) $B_K = 1/F_K$ для всех $K > 1,$
(6) $X_K = X_{K-1} + B_{K-1}$ для всех $K > 1,$
(7) $B_K > E$ для всех $K < L,$
(8) $B_L\leq E$.

module Основание2;
    var X,B,E,F : real; K,M : integer;
begin
(*  1*)     read(E); X := 1; B := 1; K := 1; F := 1;
(*  2*)     (*{X=Сумма(K-1), B=1/K!, K=1}*)
(*  3*)     while B > E do
(*  4*)             (*{X=Сумма(K-1), B=1/K!>E}*)
(*  5*)             X := X+B; K := K+1;
(*  6*)             F := F $*$ K; B := 1/F
(*  7*)             (*{X=Сумма(K-1), B=1/K!, E<1/(K-1)!}*)
(*  8*)     end;
(*  9*)     (*{X=Сумма(K-1), B=1/K!<=E, E<1/(K-1)!}*)
(*10*)     Write ('Основание натуральных логарифмов,',
(*11*)                 'найденное с точностью до',E, 'равно',X)
end Основание2.

Заметим, что еще более эффективное решение (см. программу $Основание3$) можно получить путем исключения умножения из тела цикла. Для этого воспользуемся следующими рекуррентными соотношениями:

(1) $X_1 = 1,$
(2) $B_1 = 1,$
(3) $X_K = X_{K-1} + B_{K-1}$ для всех $K > 1,$
(4) $B_K = B_{K-1} / K$ для всех $K > 1,$
(5) $B_K > E$ для всех K$К < L,$
(6) $B_L\leq E$.

module Основание3
    var X,B,E,F : real; K,M : integer;
begin
begin
(*  1*)     read(E); X := 1; B := 1; K := 1; F := 1;
(*  2*)     (*{X=Сумма(K-1), B=1/K!, K=1}*)
(*  3*)     while B > E do
(*  4*)             (*{X=Сумма(K-1), B=1/K!>E}*)
(*  5*)             X := X+B; K := K+1; B := B/K;
(*  6*)             (*{X=Сумма(K-1), B=1/K!, E<1/(K-1)!}*)
(*  7*)      end;
(*  8*)     (*{X=Сумма(K-1), B=1/K!<=E, E<1/(K-1)!}*)
(*  9*)     Write ('Основание натуральных логарифмов,',
(*10*)                 'найденное с точностью до',E, 'равно',X)
end Основание3.

Отметим прямую связь программ, реализующих первый и последний варианты. Несложный анализ программы $Основание$ позволяет выявить особенности использования в ней переменных $F$ и M. Это промежуточные (рабочие) переменные фрагмента 6-14, необходимые для вычисления (по значению переменной K) значения $1/К!$, присваиваемого переменной В в операторе 15. Этот оператор предназначен для изменения значений переменных K, X, B и E$Е$ в соответствии с переходом от утверждения 14 к утверждению 16, поэтому мы можем заменить его оператором B := B/K . В результате такой замены становится ненужным фрагмент 6-14. Его удаление завершает переход от программы Основание к программе Основание$Основание3$.
 

© В.Н. Касьянов, Е.В.Касьянова, 2004