В функциональном программировании вместо циклов, описываемых далее, может использоваться следующая функция:
FixedPoint [ f, expr ] — вычисляет expr и применяет к нему f, пока результат не перестанет изменяться;
FixedPoint [ f, expr, SameTest->comp] — вычисляет expr и применяет к нему f, пока два последовательных результата не дадут True в тесте SameTest.
Пример применения функции FixedPoint:
FixedPoint[Function[t, Print[t]; Floor[t/2]], 27]
27
13
6
3
1
0
0
Последний результат (ноль) выводится в отдельной (нумерованной) ячейке вывода и означает завершение процесса итераций — деления t на 2.
Следующий пример показывает, как можно создать цепную дробь с помощью функции Nest:
Nest[ Functiontt, 1/(1+t)], у, 3 ]
1/(1/(1/((1+y)+1)+1)+1)
Еще одна функция такого рода — это Catch:
Catch [expr] — вычисляет expr, пока не встретится Throw [value], затем возвращает value;
Catch [expr, form] — вычисляет expr, пока не встретится Throw [value, tag], затем возвращает value;
Catch [expr, form, f] — возвращает f [value, tag] вместо value. Ниже представлены некоторые конструкции циклов с оператором Catch:
Catch[ x, a, f ]
х
Catch[ Throw[ x, у ], у, fun ]
fun[x, у]
Catch[ NestList[l/(# + 1)&, -3, 5] ]
{-3,-1/2, 2, 1/3, 3/4, 4/7}
Catch[ NestList[l/(# + 1)&, -3., 5] ]
{-3., -0.5, 2., 0.333333, 0.75, 0.571429}
Catch[Do[Print[i]; If[i > 4, Throw[i+2]], i, 10]]
1
2
3
4
5
7
Реализация рекурсивных и рекуррентных алгоритмов
Рассмотрим несколько простых примеров, выявляющих суть функционального программирования. Вначале это будет пример, в котором задана функция sen [х, n], вычисляющая сумму синуса в степени n и косинуса в степени n:
scn[x_, n_] := Sin[x]^n + Cos[х]^n
scn[l, 2]
1
scn[x, 2]
1
scn[x, n]
Cos[x]n+ Sin[x]n
В этом простейшем примере результат вычислений есть возвращаемое функцией sen значение — численное или символьное. В свою очередь, функция sen в своем теле имеет встроенные функции синуса и косинуса.
Важное место в решении многих математических задач занимают реализации рекурсивных и рекуррентных алгоритмов. Напомним, что рекурсия означает обращение функции к самой себе внутри ее тела, а рекуррентность — получение результата на данном шаге по результатам вычислений на предшествующих шагах.
Рассмотрим, как это делается, с помощью описанных выше функций. Классический пример реализации рекурсивного алгоритма — вычисление факториала путем задания функции, в теле которой есть обращение к ней же самой:
f[n_] :=n*f[n-1];f[0]=l;f[1]=1;
Полезно, однако, обратить внимание на возможность явного задания результата для конкретных значений аргумента: f [ 0 ] =1 и f [ 1 ] =1. Так что рекурсия реализуется, начиная с n=2 и выше, в соответствии с классическим определением факториала.
Для реализации рекуррентных алгоритмов в Mathematica имеется ряд функций, таких как Nest или FixedPoint. В следующих примерах показано вычисление
квадратного корня из числа 5 по известному алгоритму Ньютона, записанному в виде функции newtonS:
Обратите внимание на то, что функции Nest и FixedPoint дают единственный конечный результат, тогда как функции NestList и FixedPointList возвращают еще и все промежуточные результаты итераций. Последний пример иллюстрирует остановку вычислений по заданной погрешности, равной 10
-4
.
Далее зададим функцию, реализующую алгоритм Ньютона для нахождения корня произвольного выражения f(x) при начальном значении х
0
= а, по следующим формулам:
Тогда вычисления корня из выражения е^x - 2 с начальным приближением х
0
= 0.5 при числе итераций n можно организовать с помощью функций Nest и NestList: