Преобразование выражений

14.1. Стандартная форма выражений

Все объекты, с которыми оперирует Математика, называются выражениями (Expression). Прототипом выражения является f[x,y]. Здесь f является заголовком (Head), а x и y – элементами выражения. В частности это выражение может описывать математическую функцию от двух аргументов f(x,y). В свою очередь x и y также могут быть выражениями.

Понятие выражения служит унифицирующим принципом Математики. То, что все объекты имеют подобную структуру, позволяет строить различные конструкции в разных областях применения с помощью сравнительно малого количества основных операций.

Хотя многие формулы могут быть выражены в разном виде, внутри пакета Математика эти формулы преобразуются в стандартную форму. Эту форму можно вывести на экран с помощью команды FullForm[expr]. Примеры выражений приведены в таблице 14.1. Обратим внимание, что стандартная форма записывается в виде: Заголовок[аргумент1, аргумент2,…], – где заголовок описывает основное действие, объединяющее аргументы.

14.2. Обращение к элементам выражений

К элементам любого выражения можно обращаться точно так же, как к элементам списков, используя команды:

Part[expr, n] или (expr)[[n]] – выделение элемента выражения expr с номером n;

Part[expr, {n1, n2,...}] или (expr)[[{n1, n2,...}]] – выделение списка из нескольких частей выражения. При этом заголовок выражения имеет номер “0”.

К заголовку выражения можно обращаться также с помощью команды Head[expr].

Пример 14.1 Рассмотрим заголовки выражений:

In[ ]: = Head[2] Out[ ] = Integer In[ ]: = “a”[[0]] Out[ ] = String

In[ ]: = Head[2.] Out[ ] = Real In[ ]: = f[x, y][[0]] Out[ ] = f

In[ ]: = Head[2/3] Out[ ] = Rational

14.3. Представление выражения в виде дерева

Любое выражение может быть представлено в виде дерева. Пример приведен на рис. 14.1.

Соответственно, можно говорить о глубине и об уровнях выражения. Команда Depth[expr] – подсчитывает количество уровней в выраженииexpr, а команда Level[epxr, lev] – выводит список частей выражения, стоящих на уровнях, указанных в спецификации lev.

Варианты спецификации уровней:

{n} – только один уровень с номером “n”;

n – все уровни от 1 до n;

Infinity - все уровни;

{-1} – “листья” дерева - концевые узлы.

Например, Depth[h]равно четырем; команда Level[h, {0}] выводит список нулевого уровня, включающий все выражение: {1 + (3 + x)² + y}; команда Level[h, {1}] выводит список всех трех элементов выражения h: {1, (3 + x)², y}; команда Level[h, {3}] выводит список элементов самого нижнего уровня: {3, x}; команда Level[h, {-1}] выводит список концевых узлов: {1, 2, 3, x, y}.

14.4. Операции преобразования выражений

Применение операций преобразования списков.

Приведенные в разделе 9 команды преобразования списков применимы также к любым выражениям. Рассмотрим примеры.

Пример 14.2

Введем выражение: In[ ]: = g = 1 + y + z^2;

Выделим первый подэлемент третьего элемента: In[ ]: = g [[3,1]] Out[ ] = z

Заменим первый подэлемент третьего элемента:

In[ ]: = g [[3,1]]=x+3; g Out[ ] =1 + (3 + x)² + y

Пример 14.3

Введем выражение: In[ ]: = a=E^x Out[ ] =e^x

Добавим к выражению еще один элемент: In[ ]: = b=Append[a, y] Out[ ] =

Применим циклическую перестановку: In[ ]: = RotateLeft[b, 1] Out[ ] =

Операции с заголовками выражений.

В выражении типа f[x] имя функции f само является выражением, и с ним можно производить те же действия, что и с другими выражениями.

- Можно изменять имя по правилу замены.

Пример 14.4 In[ ]: = {x, a, 5} /. List -> Plus Out[ ] = 5 + a + x

- Можно присваивать имени новое значение.

Пример 14.5 In[ ]: = f = Sin; {f[x], f[Pi/2]} Out[ ] = {Sin[x], 1}

- Можно использовать имя как аргумент.

Пример 14.6 In[ ]: = g[f_, x_]:= f[x^2]; g[Sin, y] Out[ ] = Sin[y²]

Оператор Apply.

Оператор Apply[f, expr] или f@@expr заменяет заголовок выражения на f. Apply[f, expr, lev] – применяет функцию f на уровне или уровнях, указанных в спецификации lev.

Пример 14.7 Вычисление среднего арифметического.

In[ ]: = mean[list_]:= Apply[Plus, list] / Length[list];

L1 = Table[Random[Integer, {0, 10}], {100}]; mean[L1]//N Out[ ] = 4.79

Применение операторов к частям выражений.

Функциональный оператор Map[f, expr] – применяет функцию f к каждому элементу выражения expr.

Пример 14.8 In[ ]: = Map[Cos, {a, b, Pi}] Out[ ] = {Cos[a], Cos[b], -1}

Оператор Map[f, expr, lev] – применяет функцию f к каждому элементу выражения expr на уровне, определяемом спецификацией lev.

Пример 14.9 Создадим простое выражение e1=a/b. С помощью команды Level выделим в этом выражении элементы, стоящие на первом уровне, а затем применим к ним функцию Sin. Аналогично выделим элементы второго уровня и применим к ним ту же функцию Sin. Наконец, применим функцию Sin ко всем уровням выражения e1 от первого до второго.

In[ ]: = {e1=a/b; Level[e1, {1}], Map[Sin, e1], Level[e1, {2}], Map[Sin, e1, {2}], Map[Sin, e1, 2]}

Out[ ] = {{a, 1/b}, Sin[a] Sin[1/b], {b, -1}, a Sin[b]^-Sin[1], Sin[a] Sin[Sin[b]^-Sin[1]]}

14.5. Повторное выполнение операций

Некоторые из функциональных операторов предназначены для циклической обработки выражений. Применение таких операторов часто позволяет записать итерационный процесс короче, чем с помощью обычных циклических операций.

Оператор NestList[f, expr, n] – выдаетсписок, который включает исходное выражение expr и результаты n-кратного применения к этому выражению функции f. Функция Nest[f, expr, n] – выдает только последний элемент этого списка.

Пример 14.10

In[ ]: = NestList[f, x, 3] Out[ ] = {x, f[x], f[f[x]], f[f[f[x]]]}

Пример 14.11

Составим программу для решения методом Эйлера задачи Коши для дифференциального уравнения y’(x) = f(x, y) c начальным условием y(x₀) = y₀. Введем на оси x сетку: x_i = x₀ + h*i, где h – шаг приращения аргумента x. В соответствии с методом Эйлера формула для последовательного вычисления значений y в узлах сетки имеет вид: y_i+1 = y_i + h*f(x_i, y_i).

In[ ]: = E2[f_, x0_, y0_, h_, n_]:= Module[{w},

w[{x_, y_}] = {x+h, y+h*f[x, y]}; NestList[w, {x0, y0}, n]]

Обратим внимание, что функция w является векторной функцией.

Найдем решение уравнения y’(x) = y с начальным условием y(0)=1:

In[ ]: = f[x_, y_] = y; E2[f, 0, 1, 0.05, 3]

Out[ ] = {{0, 1}, {0.05, 1.05}, {0.1, 1.1025}, {0.15, 1.15763}}

Элементы этого списка содержат значения x и y в узлах сетки с шагом 0.05. Точное решение данной задачи Коши представляет собой экспоненту: y(x) = e^x. Сравним найденное приближенное решение с точным:

In[ ]: = Table[{x, Exp[x]}, {x, 0, 0.15, 0.05}]

Out[ ] = {{0, 1}, {0.05, 1.05127}, {0.1, 1.10517}, {0.15, 1.16183}}

Оператор FixedPointList[f, expr] – генерирует список результатов повторного применения функции f к выражению expr. Список начинается с выражения expr и заканчивается, когда результаты повторного применения f перестают изменяться (в пределах точности, обеспечиваемой компьютером). FixedPoint[f, expr] – выдает только последний элемент списка.

Пример 14.12

Создадим функцию для вычисления квадратного корня числа x с помощью итерационного процесса Герона (один из вариантов такой функции приведен в разделе 8, пример 8.10):

In[ ]: = r2[x_]:= Module[{f}, f[v_] = (v+ x / v) / 2; FixedPoint[f, x+1.]]

В программе задается начальное значение x+1, которое затем уточняется в процессе последовательных итераций – повторном применении функции f. Например, найдем значение квадратного корня из двух:

In[ ]: = r2[2] Out[ ] = 1.41421

Оператор NestWhileList[f, x, test] – генерирует список {x, f[x], f[f[x]], …}; процесс генерации заканчивается, когда перестает выполняться условие test.

NestWhileList[f, x, test, m] – в качестве аргументов условия test используются m последних результатов применения функции f.

NestWhile[…] – выдает только последний элемент списка.

14.6. Анонимные функции

Анонимные функции – это функции без имени. В ряде случаев функции вводятся только для однократного использования. Например, таковы локальные функции, входящие в конструкцию Module. Если функция используется только один раз, то она и не нуждается в имени. Синтаксис анонимной функции: body &, – тело функции, заканчивающееся знаком амперсенд &. Формальными аргументами анонимной функции служат # или #1, #2, #3, … Знак & является обязательным элементом, указывающим, что данное выражение является определением анонимной функции. Амперсенд имеет самый низкий приоритет, поэтому в выражениях типа #1+#2 & тело функции не требуется заключать в скобки. С другой стороны, если анонимная функция служит правой частью выражения, то вся она должна быть взята в скобки, например: option -> (body &).

Пример 14.13

Запишем выражение, содержащее два вхождения функции Sin, а затем заменим в этом выражении Sin на возведение в квадрат:

In[ ]: = {b = Sin[a + Sin[2x]], b/.Sin->(#^2 &)} Out[ ] = {Sin[a = Sin[2x]], (a + 4 x²)²}

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

Пример 14.14

Вычисление квадратного корня с помощью процесса Герона (см. примеры 8.10, 14.12):

In[ ]: = r3[x_]:= FixedPoint[(# + x / #) / 2 &, x+1.]; r3[2] Out[ ] = 1.41421

Пример 14.15

Нахождение корня уравнения f(x)= 0 с помощью итерационного метода Ньютона. Алгоритм Ньютона описывается формулой: x_i+1 = x_i – f(x_i) / f’(x_i), где x_i – значение корня, полученное на i-ом шаге итераций. Задав подходящее начальное значение x₀, можно найти значение корня с требуемой точностью. Опишем алгоритм Ньютона с использованием циклической операции FixedPoint:

In[ ]: = Newt[f_, x0_]:= FixedPoint[# - f[#] / f’[#] &, x0]

Здесь x0 – начальное приближение. Данная программа позволяет найти корень уравнения уравнения f(x)= 0 с точностью, которую обеспечивает математический сопроцессор.

Использование циклической операции NestWhile позволяет найти корень уравнения с заданной точностью:

In[ ]: = Newt2[f_, x0_, eps_]:= NestWhile[# - f[#] / f’[#] &, x0, Abs[#1 - #2] > eps &, 2]

Итерационный процесс, описываемый данной программой, заканчивается, если два последних значения отличаются не более, чем на eps.

Найдем положительный корень уравнения x³+x- 1 = 0с точностью 10^-5:

In[ ]: = f [x_] = x^3+x-1.; Newt2[f, 1., 10^-5] Out[ ] = 0.682328

Пример 14.16

Вычисление “машинного эпсилон” (см. также примеры 7.1 и 7.2):

In[ ]: = NestWhile[# / 2. &, 1., # + 1. > 1. &]*2 Out[ ] = 2.84212*10^-14

14.7. Функциональные операторы Outer и Inner

Функциональный оператор Outer[f, list₁, list₂] называют обобщенным произведением. Оператор применяет функцию f ко всем сочетаниям элементов списков list₁, list₂.

Пример 14.17

In[ ]: = Outer[f, {a, b}, {1, 2}] Out[ ] = {{f[a, 1], f[a, 2]}, {f[b, 1], f[b, 2]}}

Пример 14.18

Вычисление матрицы частных производных.

In[ ]: = (jac[f_List, v_List]:= Outer[D, f, v];

fun = {x^2 + 3 y, Sin[x] – Cos[y]}; var = {x, y}; jac[fun, var])

Out[ ] = {{2 x, 3}, {Cos[x], Sin[y]}}

Оператор Inner[f, list₁, list₂, g] в отличие от оператора Outer составляет сочетания элементов, стоящих на одинаковых местах в списках list₁, list₂. К этим сочетаниям оператор применяет функцию f, а затем к списку результатов применяет функцию g, либо просто суммирует результаты, если функция g не указана.

Пример 14.19

In[ ]: = Inner[Plus, {a, b}, {1, 2}, Times] Out[ ] = (1 + a) (2 + b)

Пример 14.20 Найдем скалярное произведение двух векторов:

In[ ]: = Inner[Times, {a, b}, {c, d}] Out[ ] = a c + b d

Вопросы для повторения

1. Основные части пакета Математика.

2. Точные и приближенные вычисления. Функция N[].

3. Операции с ячейками: объединение и разделение ячеек, группирование ячеек. Скрытие содержания группы ячеек.

4. Глобальный характер данных в течение сеанса работы в пакете Математика. Обращение к ячейкам. Удаление данных.

5. Правила написания. Малые и большие буквы. Запись операции умножения. Употребление скобок.

6. Наиболее часто употребляемые операции и функции. Тригонометрические функции. Экспоненциальная функция и логарифм. Вычисление пределов. Правило преобразования. Функция замещения. Вычисление производных. Численное и аналитическое интегрирование. Нахождение минимумов и максимумов. Циклические операции суммирования и умножения. Функция Fit. Функция Print. Получение информации о функциях.

7. Стандартная, префиксная и постфиксная формы обращения к функциям. Приоритеты обращений.

8. Циклические операции: For, While и Do. Логические операторы. Функция If.

9. Функции пользователя. Операции немедленного и задержанного присваивания. Шаблоны для описания типов аргументов.

10. Альтернативные определения функций на разных отрезках значения аргумента. Функция Which.

11. Составление программ. Конструкция Module.

12. Понятие списка. Простой способ определения списка. Функции Range и Table. Операции с элементами списков. Преобразования списков. Определение векторной функции. Матричные функции.

13. Массивы.

14. Типы двумерных графиков. Основные опции графиков. Установление одинакового масштаба по осям координат. Функции Show, GraphicsRow, GraphicsGrid. Типы трехмерных графиков.

15. Анимация.

16. Функция Manipulate.

17. Аналитические операции: Series, Expand, Simplify.

18. Решение уравнений. Функции: Solve, LinearSolve, Roots, FindRoot.

19. Решение дифференциальных уравнений. Функции: DSolve, NDSolve.

20. Понятие выражения. Представление выражений в форме FullForm. Уровни выражения. Операции с элементами выражений. Операции с заголовками выражений.

21. Функциональный оператор Apply. Повторное выполнение операций; операторы:

NestList, FixedPointList, NestWhileList.

22. Анонимные функции. Применение анонимных функций совместно с циклической обработкой выражений.

23. Оператор Outer.

Дата добавления: 2015-07-08