Работа с выражениями

  Одним из важнейших понятий системы Mathematica является математическое выражение, или просто выражение — ехрг (от английского слова expression). Работа с математическими выражениями в символьном виде — основа основ символьной математики.

Выражение может быть представлено в общепринятом виде (как математическая формула или ее часть) с помощью операторов, например, а* (х + у + z) или х ^{^} у, оно может задавать и некоторую функцию f [х, у,...] или их комбинацию. Наряду с такой формой существует так называемая полная форма представления выражений, при которой основные арифметические операции задаются не операторами, а только соответствующими функциями. Ее примеры даны ниже.

Для вывода выражения ехрг в полной форме используется функция FullForm [ехрг ]. Примеры перевода выражений в полную форму:

1+х^2+(у+г)^2+2

3 + х2 + (y+z)2

FullForm[%]

Plus[3, Power[x, 2], Power[Plus[у, z] , 2]]

Integrate[a*Sin[b*x]*Exp[-c*x],x]

a [(be-cxCos[bx])/{-ib + c) (ib + c)-( ce+cxSin[bx]) \(-ib + c) (ib + c) ]

FullForm[%]

Times[a, Plus[Times[-1, b, Power[Plus[Times[Complex[0, -1], b], c] , -1], Power[Plus[Times[Complex[0, 1], b], c] , -1], Power[E, Times[-l, c, x] ] , Cos[Times[b, x] ] ] , Times[-1, c, Power[Plus[Times[Complex[0, -1], b] , c], -1] , Power[Plus[Times[Complex[0, 1] , b], c] , -1] , Power[E, Times[-1, c, x] ] , Sin[Times[b, x]]]]]

Для определения типа выражения служит функция Head [ехрr ]. Применительно к числовым выражениям она возвращает тип результата, как показано в приводимых ниже примерах.

Ввод (In)	Вывод (Out)
1+2+3	6
Head[%]	Integer
Head[123/12345]	Rational
Head[2*0.25]	Real

Следующие примеры поясняют действие функции Head для символьных выражений:

Head[f [x,y, z] — возвращает f; Head[a+b+c] — возвращает Plus; Head[x ^{^} n] — возвращает Power; Head[ {a, b, с} ] — возвращает List. Другая пара примеров показывает применение Head в списках с разнородными выражениями:

{Head[l + 2], Head[аЬ] , Head[ 5/7], Headfl + 3i], Head[e2]}

{Integer, Times, Rational, Complex, Power}

Head/@{l, 1/3, 2.1, 2 + 3i, x, f [x] , {1, 2, 3}, a+b, a/b}

{Integer, Rational, Real, Complex, Symbol, f, List, Plus, Times}

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

Основные формы записи выражений

Возможны четыре основные формы записи выражений:

f [х, у] — стандартная форма для f [х, у]; f @ х — префиксная форма для f [ х ]; х / / f — постфиксная форма для f [ х ]; х ~ f ~ у — инфиксная форма для f [ х, у ]. Далее приведены примеры применения этих форм.

Ввод (In)	Вывод (Out)
F[x_] = 2*х^2	2X 2
F[a]	2a 2
a//F	2 a 2
f [x_, y_] = х^ 2 + у^2	y 2 +x 2
f[a,b]	a 2 +b 2
a-f-b	a 2 + b 2

Можно использовать ту или иную форму выражений в зависимости от класса решаемых математических задач.

Части выражений и работа с ними

Сложные выражения состоят из частей, которые могут интерпретироваться различным образом.

Работа с частями выражений напоминает работу со списками. Для выделения любой заданной части выражения используются функция Part или двойные квадратные скобки;

Part [expr, n] или expr [ [n] ] — выделяет п-ю часть выражения, начиная с начала; expr [ [-n] ] — выделяет п-ю часть выражения, начиная с конца; expr [ [nl,n2,...] ] — выделяет части выражения и показывает их в форме дерева; expr [[{nl, n2,...}]] — дает комбинацию нескольких частей выражения. Приведем примеры использования этих средств. Нередко выражения рассматриваются как возможные значения переменных. В этом случае используются операторы присваивания переменным заданных значений. Mathematica имеет два типа присваивания — с помощью символов «: =» и с помощью символа «=». Они различаются временем вычисления выражения, следующего за этими символами. Знак «: =» используется для задержки присваивания до вычисления правой части, например:

f[x_] := % + 2 х

Вывода здесь нет. Продолжим наш эксперимент: 1 + у^2

1 + y2

g[х_] = % + 2 х

1 + 2 х + у2

Теперь вывод есть, так как % (ссылка на предыдущий результат) определена в виде выражения 1 + у^2 и при задании [х_] использован оператор немедленного присваивания. Далее:

2 + z

2 + z

{f[a],g[a]>

{2 + 2a+z, 1 + 2 а + у2}

Следующие функции возвращают особые части выражения:

Denominator [expr] — возвращает знаменатель выражения ехрг; First[expr] — возвращает первый элемент из ехрг; Last[expr] — возвращает последний элемент из ехрг; Rest [expr] — возвращает ехрг с удаленным первым элементом. Ниже приводятся примеры применения этих функций.

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

Удаление элементов выражения

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

Delete [expr, n] — удаляет элемент в позиции п в выражении ехрг. Если п отрицательно, позиция отсчитывается с конца; Deletefexpr, (i, j,...}] — стирает часть выражения в позиции {i, j ,...}; Delete [expr, {{i1, j1,...}, {i2, j2,...},...}] — удаляет части выражения в нескольких указанных позициях; DeleteCases [expr, pattern] — удаляет все элементы выражения expr, которые совпадают с образцом pattern; DeleteCases[expr, pattern, levspec] — удаляет все части выражения ехрг на уровнях, указанных levspec и соответствующих образцу pattern. Следующие примеры иллюстрируют применение этих функций.

Обратите внимание на то, что в общем случае выражения могут быть многоуровневыми. Уровень задается спецификацией levspec.

Другие манипуляции с выражениями

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

Append [expr, elem] — возвращает ехрг с дополнением elem; AppendTo [s, elem] — добавляет elem к значению s и присваивает s новое значение; Apply [f, expr, levelspec] — возвращает ехрг, замещая заголовки в тех частях ехрг, которые указаны спецификацией уровня levelspec; Cancel [expr] — возвращает ехрг с сокращением общих множителей числителя и знаменателя; Cases [expr, pattern, levelspec] — возвращает список всех частей выражения expr на уровнях, указанных спецификацией levelspec, которые соответствуют шаблону pattern; Chop [expr] — присваивает значение 0 тем приближенным вещественным числам в выражении expr, абсолютные величины которых меньше 10 ^-10 ; Chop [expr, tol ] — присваивает значение 0 тем приближенным вещественным числам в выражении expr, абсолютные величины которых меньше tol; Replace [expr, rules] — возвращает expr с подстановкой, заданной правилом или списком правил rules; ReplaceAll — используется в виде expr /. rules и возвращает expr с подстановками, заданными правилом или списком правил rules; ReplacePart [expr, new, n] — возвращает выражение, в котором п-я часть expr заменена на new; ReplacePart [expr, new, {i, j,...}] — заменяет на new часть в позиции {i, j,...}; ReplacePart [expr, new, {{il, jl,...}, {i2, j 2 ,...},...}] — заменяет на new части в нескольких позициях выражения; ReplaceRepeated — применяется в виде expr //. rules и неоднократно выполняет замещения до тех пор, пока expr не перестанет изменяться. Действие этих функций достаточно очевидно и поясняется следующими примерами.

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

Контроль выражении

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

AtomQ [expr] — возвращает True, если выражение ехрг не может быть разложено на подвыражения и является атомарным, и возвращает False в противном случае; FreeQ [expr, form] — возвращает значение True, если в выражении ехрr отсутствует подвыражение, совпадающее с form, в противном случае возвращает False; FreeQ[expr, form, levelspec] — тестирует только части выражения на уровнях, указанных levelspec. Следующие примеры показывают действие этих функций.

 

Приложение имени функции к выражению или его части

Функции в системе Mathematica характеризуются именем (обобщенно — f) и выражением ехрг, задающим функциональную зависимость. Обычно функция в ответ на обращение к ней возвращает значение выражения — численное или символьное. Однако в системе Mathematica понятие функции значительно расширено, и она может возвращать любой объект, в том числе графический или звуковой. Можно сказать, что входной язык общения с системой Mathematica основан на принципах функционального программирования с применением полных форм представления выражений.

Следующие функции позволяют прикладывать имя функции к выражению или к частям выражения:

Apply [f, expr] — замещает заголовок выражения ехрг на f; Nest [f, expr, n] — возвращает выражение, полученное и-кратным применением f к ехрг; Map [f, expr] — применяет f к каждому элементу на первом уровне в ехрr; Map[f, expr, levelspec] — применяет f к частям ехрг, указанным с помощью levelspec; MapAll [f, expr] — применяет f ко всем частям выражения ехрг. Приведем примеры действия этих функций.

Ввод (In)	Вывод (Out)
Apply [f, {a, b, x}]	f [a, b, x]
Nest[f , x, 3]	f[f[f[x]]]
s[x_, y_, z_] := x + y + b
N[Apply[s, {1, 2, a}]]	3. + b
Map[f, {а, Ь, с}]	{f[a], f[b], f[c]}
MapAll [f, a*x + b]	f[f[b] + f[f[a] f[x]]]
MapAll [f, {а, Ь, с}]	f[{f[a], f[b] , f[c]}]

 

Укороченная форма функций

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

Укороченная форма	Полная форма
f @ ехрг	f [expr]
f @@ ехрг	Apply [f, expr]
f /@ ехрг	Map[f, expr]
f //@ ехрг	MapAll [f, expr]

Смысл укороченных выражений очевиден. Приведем несколько примеров их использования.

Ввод (In)	Вывод (Out)
f@{a, b, с}	f[{a, b, c}]
f@@{a, b, c}	f [a, b, c]
f /@{a, b, c}	{f[a], f[b], f[c]}
f//@{a, b, x}	f[{f[a], f[b], f[x]}]

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

Выделения и подстановки в функциях

Функция Slot[n], или, в укороченной форме, #n, представляет n-й аргумент функции. Это иллюстрируют следующие примеры.

Объект # эквивалентен #1, a #0 — заголовку абстрактной функции. Таким образом, F[#.#2]&F[a,b] эквивалентно F[a,b].

Функция SlotSequence [n], или, в укороченной форме, ##n, где п = 1, 2, ..., представляет порядок применения формальных аргументов к абстрактной функции. Таким образом, объект ##n определяет последовательность аргументов, начиная с n-го.

Представленные средства обеспечивают работу с функциями на абстрактном уровне.

Интересные возможности связаны с использованием подстановок при определении функций. Система допускает использование подстановок в виде f [x] = value и f[x_] = value.

Поясним это несколькими примерами.

Как нетрудно заметить из этих примеров, подстановки в функциях могут существенно изменить исходную функциональную зависимость. А потому важной областью их применения является модификация функций.

Рекуррентные функции

Использование подстановок при определении функций позволяет легко реализовывать рекуррентные алгоритмы, то есть алгоритмы, при которых очередной шаг вычислений основан на определенном преобразовании предшествующих шагов. Примером может служить задание функции вычисления факториала fact [n], представленное ниже.

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

Дополнительные примеры работы с функциями

Приведем еще ряд примеров действия функций Apply, Map и Nest.

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

Вычисление среднего для элементов списка:

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

VectorQ[list] && Length[list] > 0

General: :spell! : Possible spelling error: new

symbol name "list" is similar to existing symbol "List".

Вычисление среднего геометрического для списка:

GeometricMean[list_] : = Apply

[Times, list"4 (I/Length [list])] /;

VectorQ[list] && Length[list] > 0

Вычисление гармонического среднего для списка:

HarmonicMean[list_] := Length[list]

/ Apply[Plus, I/list] /;

VectorQ[list] && Length[list] > 0

Обратите внимание на то, что при задании первой функции Mathematica предупреждает о том, что введенный идентификатор list подозрительно напоминает зарезервированный идентификатор List. Все приведенные выше функции не имеют смысла, если список пустой. Поэтому в них введен контроль за такой ситуацией.

Теперь можно выполнить расчеты по этим формулам.

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

Инверсные функции

Инверсными функциями называют функции, полученные в результате обращения заданных функций. Например, для функции Sin [x] инверсной будет ArcSin [х] и т. д. Следующие функции обеспечивают представление инверсных функций:

InverseFunction [f ] — представляет функцию, обратную для f, то есть определенную таким образом, что InverseFunction [f ] [у] возвращает значение х, для которого f [х] равно у. Для функции нескольких переменных InverseFunction [ f ] представляет обращение по первому аргументу; InverseFunction [f, n] — представляет обращение по п-му аргументу; InverseFunction [f, n, tot] — представляет обращение по п-му аргументу, когда имеется всего tot аргументов. Следующие примеры иллюстрируют работу с этими функциями.

Ввод (In)	Вывод (Out)
InverseFunction [Sin]	ArcSin
%[х]	ArcSin[x]
Composition [ f , g , h]	Ccrrposition[f , g, h]
InverseFunction [Composition [% , q] ]	Corpositiont [q- 1 , h- 1 , g- 1 ,f- 1]

Обратите внимание на то, что в этих примерах фигурируют заголовки функций — например, для получения инверсной функции от Sin [х] следует использовать

Sin в качестве аргумента f функции InverseFunction [f].

Задание математических отношений

Символьные преобразования- при всей их кажущейся таинственности осуществляются по определенным, хотя и весьма многочисленным, а потому для нас запутанным, правилам. Основные из них давно известны из математики и описаны в многочисленных справочниках и монографиях. Они записаны в ядре системы и вызываются из него при создании условий, необходимых для выполнения того или иного преобразования. Если этих условий нет, исходное выражение просто повторяется. А если обнаружена явная ошибка в преобразованиях, то о ее сути выводится соответствующее сообщение. При ситуациях, лишь близких к ошибочным, выводится предупреждающее сообщение, и вычисления продолжаются.

Однако математика и использующие ее науки непрерывно развиваются. Появляются все новые и новые правила преобразований. Пользователь-математик может пожелать изменить встроенные правила преобразований — например, для создания новых разделов математики, базирующихся на каких-либо новых представлениях. Блестящий пример этого — теория относительности Эйнштейна.

Таким образом, возникает необходимость расширения математических символьных систем и обучения их новым правилам математических преобразований. Система Mathematica имеет и такие возможности. Поясним на простых примерах, как это делается.

В математике можно найти множество примеров математических отношений. Например, хорошо известно такое отношение для логарифма и экспоненциальной функции:

log(exp(x)) = х.

Не обременяя себя поиском действительно новых закономерностей (порой на это может не хватить жизни, да и везет не каждому ученому), зададим приведенную закономерность для введенных по-новому функций log и ехр. Центральным моментом тут является введение новых имен функций, которые начинаются с малых букв, а не с больших, как у встроенных функций Log и Ехр. Поэтому система воспринимает log и ехр как новые функции.

Итак, вводим «новую» закономерность следующим образом:

log[exp[x_]] :=x

General::spelll : Possible spelling error:

new symbol name "log" is similar to existing symbol "Log".

General::spelll : Possible spelling error:

new symbol name "exp" is similar to existing symbol "Exp".

Система на всякий случай сообщает о рискованности эксперимента — символы log и ехр похожи на зарезервированные имена функций Log и Ехр. Проигнорировав это предупреждение, проверим введенную закономерность в работе.

Итак, наша «новая» закономерность работает. Можно ввести, скажем, и такое известное отношение:

log[x_^n_] :=n*log[x]

Проверим, какие отношения заданы нами для функции log:

?log

Global' log

log[exp[x_] ] : = x

log[x_n-] := n log[x]

Проверим введенные правила, например, так:

5lоg[[1+х]^5]

5lоg[1+х]

Рассмотрим еще пару примеров задания «новых» математических правил. В первом примере задано правило — логарифм произведения равен сумме логарифмов сомножителей:

log[x_*y_] := log[x] +log[y]

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

log[a*b*c*d*e]

log [a] + log[b] + log[c] + log[d] + log[e]

Второй пример иллюстрирует задание объекта, ассоциированного со списком:

а /: а[х_] +а[у_] :=а[х + у]

а[х] + а[у] +a[z]

а[х+ у+ z]

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

 

Функции компьютерной алгебры

  Системы компьютерной алгебры имеют несколько характерных для них функций, выполняющих достаточно сложные преобразования выражений. Эти функции имеют вполне установившиеся названия (Simplify, Expand, Collect, Factor и т. д.) и встречаются практически во всех системах символьной математики. Настало время детально познакомиться с ними, что и делается в данном разделе.

Упрощение выражений — функция Simplify

Упрощение математических выражений — одна из самых важных задач символьной математики. Частенько невероятно сложное математическое выражение, пугающее новичков своим грозным видом, является просто нулем или единицей либо сводится к простому выражению после ряда вполне заурядных (хотя, порою, и довольно сложных) преобразований. Качество выполнения операции упрощения во многом определяется мощью ядра математической системы, поскольку зависит от числа заложенных в него функций и правил преобразования выражений.

С точки зрения простоты выражений они делятся на недостаточно простые и достаточно простые выражения. Недостаточно простые выражения таят в себе всевозможные «излишества»: сокращаемые общие члены, лишние переменные и функции, полиномы со степенями, допускающими понижение, и т. д. Это затрудняет качественный анализ выражений и может даже приводить к неоднозначным и даже неверным результатам.

Mathematica всегда старается упростить то или иное выражение, если для этого не требуется каких-либо особых средств. Например, сложные выражения, содержащие элементарные или специальные функции, превращаются в более простые выражения — в том лишь смысле, что они состоят из более простых функций. Следующие примеры иллюстрируют это.

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

Для упрощения выражений используется функция Simplify [ехрг]. Она исполняет последовательность алгебраических преобразований над выражением ехрг и возвращает простейшую из найденных форм (обычно это бывает нормальная форма выражения).

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

Приведем наиболее характерные результаты действия функции Simplify.

Следующие примеры дополнительно поясняют применение функции Simplify.

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

Вообще говоря, понятие упрощения математических выражений не является однозначным. К примеру, некоторые пакеты символьной математики упрощают sin(x)/cos(x) к единой математической функции tan(x), тогда как другие упрощают tan(x) к sin(.r)/cos(.r), считая, что функции sin(x) и cos(.r) более простые, чем функция tan(.r). Эта неоднозначность часто путает неопытных пользователей, пытающихся проверить символьные системы примерами из справочников, — вполне возможно, что авторы их придерживались несколько иного подхода к упрощению выражений, чем разработчики той или иной математической системы.

Функция полного упрощения FullSimplify

Функция FullSimplify, область применения которой в Mathematica 4 заметно расширена, обладает заметно большими возможностями, чем функция Simplify. В частности, она обеспечивает упрощение выражений, содержащих специальные математические функции:

Simplify [Gamma [х] *х* (х+1) * (х+2) * (х+n) ]

х(1+х) (2 + х) (n+x) Garrma[x]

FullSimplify [Gamma [х] *х* (х+1) * (х+2) * (х+n) ]

(п+ х) Garrma[3 + х]

Simplify[Tan[x] , ComplexityFunction-> (Count[{#l}, _Tan, \ [Infinity]]*;)]

Tan[x]

FullSimplify [Tan [x] , ComplexityFunction -> (Count[{#l}, _Tan,

\ [Infinity]] &)]

Как видно из этих примеров, функция FullSimplify обеспечивает упрощение даже в том случае, когда функция Simplify пасует. Неплохо упрощаются тригонометрические функции, особенно при использовании опции Complexity-Function, подсказывающей путь упрощения.

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

Раскрытие и расширение выражений — функции класса Expand

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

(а -b)2 = (а - b) (а - b)

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

a2-2ab + b2

Разумеется, такое соответствие существует далеко не всегда. К примеру, выражение в виде числа 1 вовсе не является представлением только выражения sin(X) ² + cos(x) ² .

Ниже представлены основные функции, производящие раскрытие и расширение выражений:

ComplexExpand[expr] — раскрывает ехрг, полагая все переменные вещественными; ComplexExpand [expr, {x1, х2,...}] — раскрывает ехрг, считая переменные xi комплексными; FunctionExpand [expr] — раскрывает выражения ехрг, содержащие специальные функции; Expand [ехрг ] — раскрывает произведения и положительные целые степени в ехрг; Expand [expr, patt] — выполняет расширение только для тех элементов ехрг, которые содержат соответствующие шаблону patt члены; Exp_andAll [expr] — раскрывает все произведения и целочисленные степени в любой части ехрг; ExpandAll [expr, patt] — исключает из операции расширения те части ехрг, которые не содержат соответствующие шаблону patt члены; ExpandDenominator [expr] — раскрывает произведение и степени, которые присутствуют в выражении ехрг в роли знаменателей; ExpandNumerator [expr] — раскрывает произведения и степени в числителе выражения ехрг; PowerExpand[expr] — раскрывает вложенные степени, степени произведений, логарифмы от степеней и логарифмы от произведений. Осторожно используйте PowerExpand, так как эта функция не реагирует на разрывный характер выражения ехрг. Приведем примеры операций расширения выражений с помощью функции Expand:

Expand[(х - а)*(х - b)*(х - с)]

-abc+ abx + acx+bcx-ax2- bx2-cx2 + x3

Simplify[%]

-(а-х) (-b+х) (-с + х)

Expand!(Sin[x]+Cos[x])/(Cos[x]*Sin[x])]

Csc[x] + Secfx]

Simplify[%]

Sirrplfy[Csc[x] + Sec[x] ]

Expand[2*Cos[x]^2,Trig-> True]

2Cos[x]2

Simplify[%]

l+Cos[2x]

Expand[Sin[x]^2+Cos[x]^2]

Cos[y]2+Sin[x]2

Expand[Sin[x]^2+Cos[x]^2,Trig-> True]

1- Cos[x]2/2 +Cos [у]2/2 +Sin[x]2/2 -Sin[y]2/2

Simplify[%]

1/2 (2-Cos[2x] + Cos[2y])

В этих примерах полезно обратить внимание на то, что далеко не всегда последовательное применение функций Expand и Simplify дает исходное выражение. Гораздо чаще получается новое выражение, порой представляющее ценность. При операциях с тригонометрическими выражениями нередко нужно использовать опцию Trig->True, намечая тригонометрический путь решения. В противном случае может быть просто выдан отказ от выполнения операции Expand с заданным выражением, которое будет просто повторено в ячейке вывода.

Приведем примеры использования других функций расширения выражений:

ExpandAll[Sin[2*Cos[x]], Trig -> True]

Cos [Cos [x] + ISin[x] ] Sin[Cos[x] - ISin[x] ] +

Cos [Costx] - ISintx] ] Sin[Cos[x] + ISin[x] ] Simplify[%]

Sin [ 2 Cos [x]]

ExpandNumerator[(1 + x)^2/х]

1 + 2 x + x2/x

ExpandDenominator[(1 - x)^2/(l + x)^2]

(1-х)2/1 + 2 x + x2

ComplexExpand[Sin[a + I*b]]

Cosh[b] Sin [a] + I Cos [a] Sirihfb]

ComplexExpand[ (a. + b I) / (x + d I) ]

-lad/Abs[Id+x]2+bd/Abs[Id+x]2 + ax/Abs[Id + x]2 +Ibx/Abs[Id+x]2

Simplify[%]

(-Ia + b) (d + Ix)/^bstld+x]2

PowerExpand[Sqrt[a^2*b*c]]

aSQRT(b)SQRT(c)

FunctionExpand[Gamma[4, x]]

E-xx3+ 3 (Fxx2+ 2 (E-x+ E-xx))

FunctionExpand[Beta[4, 2 + x]]

6/(2 + x) (3+x) (4 + x) (5 + x)

FunctionExpand[Zeta[3, 2 + x] ]

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

Функция приведения Collect

К операциям, расширяющим выражения, относится также функция Collect:

Collect[expr, x]— выполняет приведение общих членов выражения по степеням переменной х; Collect [expr, {x1, x2, ...}]— выполняет приведение общих членов выражения по степеням переменных xl, х2, ... Эта операция особенно полезна, если результат можно представить в виде степенных многочленов. Проиллюстрируем это следующими примерами.

Следующий пример показывает применение функции Collect к выражению с двумя переменными:

Collect[(х-1)*(у-3)*(х-2)*(у-2)*(х-1),у,х]

-12.+ 30х-24х2+ 6х3 + (10-25х + 20Х2- Sx3) y+

(-2+ 5х-4х2 + х3) у2

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

Функции преобразования тригонометрических выражений

Хотя представленные выше функции иногда применимы для тригонометрических выражений, для последних есть ряд специальных функций, дающих более надежные результаты в ходе преобразований тригонометрических функций. В названии этой группы функций имеется слово Trig. Начнем с функции Trig-Expand [expr ], которая обеспечивает расширение выражения ехрг, содержащего тригонометрические и гиперболические функции. Представленные ниже примеры иллюстрируют работу этой функции:

TrigExpandfSin[а+b]]

Cos[b] Sin[a] +Cos[a] Sin[b]

TrigExpand[Cos[3*x]] TrigExpand[Cos[3*x]]

Cos[x]3-3Cos[x] Sin[x]2

TrigExpand[Sinh[2^x]]

2Cosh[x] Sinh[x]

TrigExpand[Sin[Cos[Tan[x]^2]]]

Cos[1/2Cos[Tan[x]2] + 1/2ISin[Tan[x]2]

Sin[1/2Cos[Tan[x]2] - 1/2ISin[Tan[x]2]

Cos[1/2Cos[Tan[x]2] - 1/2ISin[Tan[x]2]

Sin[1/2Cos[Tan[x]2] + 1/2ISin[Tan[x]2]

TrigExpand[Sin[2*x]-Cos[3*x]^2]

1/2 Cos[x]6/2+2Cos[x] Sin[x] + 15/2Cos[x]4Sin[x]2

15/2Cos[x]2/Sin[x]4+Sin[x]6 /2

TrigExpand[Sin[2 ArcCoth[t]]]

2 Cos [ArcCoth[ t] ] Sin[ArcCoth[ t] ]

Следующие две функции обеспечивают взаимные преобразования экспоненциальных и тригонометрических выражений:

TrigToExp [expr] — преобразует тригонометрические выражения к экспоненциальному виду; ExpToTrig [expr] — преобразует экспоненциальные выражения в тригонометрические.

Примеры применения этих функций:

TrigToExp[Cos[z]]

1/2( EIz+EIz)

ExpToTrig [ % ]

Cos [ z]

f := Sinh[z] + Cosh[z] TrigToExp[f]

Ez

ExpToTrig[%]

Cosh[z] + Sinh[z]

TrigToExp[Sin[x]/Cos[y]]

I (E-IX- EIX)/(E-IX+ EIX)

ExpToTrig[%]

Sec[y] Sin[x]

Приведем еще две функции:

TrigFactor [expr] — раскладывает на простые множители тригонометрическое выражение ехрr; TrigFactorList [expr] — раскладывает тригонометрическое выражение ехрг на списки с термами выражения. Следующие примеры показывают применение этих функций:

expr = TrigExpand[Sin[a + b]^3]

3/4Cos[b] Sinfa] - 3/4 Cos [a]2 Cos [b]3 Sin [a] +

1/4 Cos[b]3Sin[a]3 + 3/4 Cos[a] Sin[b]-

3/4Cos[a]3Cos[b]2Sin[b] +9/4 Cos[a] Cos[b]2Sin[a]2 Sin[b] +

9/4 Cos[apCos[b] Sin [a] Sin[a]2-3/4 Cos[b] Sin[a]-3 Sin[b]2 +

1/4Cos[a]3Sin[b]3-3/4 Cos[a] Sin[a]2Sin[b]3

TrigFactor[expr]

Sin[a+b]3

TrigFactorList[expr]

{{1, 1}, {Sin[a+b] , 3}}

TrigExpand[Cosh[Sin[x*y]]]

Cos[1/2 Cos[xy] - 1/2 ISin[xy]] Cos[1/2 Cos[xy] + 1/2 ISin[xy]]

Sin[1/2Cos[xy] -1/2 ISin[xy]] Sin[1/2 Cos[xy] + 1/2 ISin[xy]]

TrigFactorList[%]

{{1, 1}, {Cosh[Sin[xy]], 1}}

Наконец, функция TrigReduce [expr] упрощает выражения с произведениями тригонометрических функций.

Примеры применения этой функции:

TrigReduce[2*Sin[x]*Cos[у]]

Sin[x- у] + Sin[x + y]

TrigReduce[Cosh[x]*Tanh[x]]

Sinh[x]

TrigReduce[Sin[x]^2 + Cos[x]^2]

1

TrigReduce[Sin[x]*Cos[x]]

1/2 Sin[2x]

TrigReduce[Sinh[x/y]^3]

1/4 (-3Sinh[x/y] + Sinh[3x/y])

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

Основные операции над полиномами

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

Р(х) = а0 + а1х + а2 х2 + а3 х3 + ... + аnхn.

Хотя термин «полином» не очень прижился в отечественной математической литературе, мы оставляем его ввиду краткости и ради лучшего понимания синтаксиса функций системы, поскольку слова poly и Polynomial входят в параметры и имена многих функций. При этом полиномы мы будем кратко обозначать как poly или pi (здесь i — индекс или порядковый номер полинома).

Над полиномами можно выполнять обычные арифметические операции: сложение, вычитание, умножение и деление. Это иллюстрируют следующие примеры (здесь р! и р2 — полиномы от одной переменной х):

р1 := х^3 + 2*х^2 + 3*х + 4

р2 := х^2 - 1

р1 + р2

3+3х+3х2+х3

р1 - p2

5+3х+х2+х3

Expand[pl*p2]

-4- 3х + 2х2 + 2х3 + 2х4 + х5

pl/p2

[4 + Зх+2х2 + х3]/[-1 + х2]

Simplify[(х^5 + 2*х^4 + 2*х^3 + 2*х^2 - 3*х - 4)/(х^2 - 1)]

4+3х+2х2+х3

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

Если один полином делится на другой (это бывает далеко не всегда), то для получения результата надо использовать функцию Simplify. В общем случае при делении полиномов может оставаться остаток. Функция, обеспечивающая деление полиномов и вычисляющая остаток, описана ниже.

Разложение полиномов — функции класса Factor

Разложение чисел, математических выражений и особенно полиномов на простые , множители является столь же распространенной операцией, что и функции Simplify, Collect и Expand. Имеется целый ряд функций, в названии которых есть слово Factor и которые решают указанные задачи:

Factor [poly] — выполняет разложение полинома над целыми числами; Factor [poly, Modulus->p] — выполняет разложение полинома по модулю простого числа р; Factorlnteger [n] — возвращает список простых множителей целого числа п вместе с их показателями степеней. Опция FactorComplete позволяет указать, следует ли выполнять полное разложение; FactorList [poly] — возвращает список множителей полинома с их показателями степени. Опция Modulus->p позволяет представить множители полинома по модулю простого числа р; FactorSquareFree [poly] — записывает полином в виде произведения множителей, свободных от квадратов. Опция Modulus->p позволяет представить разложение полинома по модулю простого числа р; FactorSquareFreeList [poly] — возвращает список множителей полинома, свободных от квадратов, вместе с показателями степени. Может использоваться опция Modulus->р; FactorTerms [poly] — извлекает полный (общий) числовой множитель в poly; FactorTermsList [poly] — возвращает лист всех общих числовых множителей полинома poly. Далее представлен ряд примеров применения этих функций.

Обычно функция Factor выявляет внутреннюю суть полинома, раскладывая его на множители, содержащие корни полинома. Однако в ряде случаев корни полинома удобнее получать в явном виде с помощью уже рассмотренной функции Roots.

Функция Factor может работать и с тригонометрическими выражениями, поскольку многие из них подчиняются правилам преобразований, присущим полиномам. При этом тригонометрический путь решения задается опцией Trig->True. Это иллюстрируют следующие примеры.

Ввод (In)	Вывод (Out)
Factor [Csc[x] + Sec[x], Trig -> True]	Csc[x] Sec[x] (Cos[x]+ Sin[x] )
Factor [ Sin [3*x] , Trig -> True]	(1+ 2Cos[2x]) Sin[x]

 

Функции для работы с полиномами

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

Decompose [poly, x] — выполняет разложение полинома, если это возможно, на более простые полиномиальные множители; GroebnerBasis [ {polyl, poly2,...}, {xl, х2,...}]—возвращает список полиномов, которые образуют базис Гробнера для идеала, порожденного полиномами polyi; Polynomial-Division [p, q, x] — возвращает список частного и остатка, полученных делением полиномов р и q от х; PolynomialGCD [polyl, poly2,...] — возвращает наибольший общий делитель ряда полиномов polyl, poly2, ... С опцией Modulus->p функция возвращает наибольший общий делитель по модулю простого числа р; PolynomialLCM[polyl, poly2,...] — возвращает наименьшее общее кратное полиномов polyl, poly2, ... С опцией Modulus->p функция возвращает наименьшее общее кратное по модулю простого числа р; PolynomialMod [poly, m] — возвращает полином poly, приведенный по модулю m; PolynomialMod [poly, {ml, m2,...}] — выполняет приведение по модулю всех mi; PolynomialQ [expr, var] — возвращает значение True, если expr является полиномом от var, иначе возвращает False; PolynomialQ [expr, {varl,...}] — проверяет, является ли expr полиномом от vari; PolynomialQuotient [р, q, х] — возвращает частное от деления р и q как полиномов от х, игнорируя какой-либо остаток; PolynomialRemainder [р, q, х] — возвращает остаток от деления р на q как полиномов от х; Resultant [polyl, poly2, var] — вычисляет результант полиномов polyl и poly2 по переменной var. С опцией Modulus->p функция вычисляет результант по модулю простого числа р. Итак, работа с этими функциями, по существу, сводит операции с таким сложным видом символьных данных, как многочлены, к типовым алгебраическим операциям над обычными символьными переменными. Следующие примеры поясняют работу с полиномами:

Р[х] := а*х^3 + b*х^2 + с*х + d

Q[x] := е*х^2 - f*x - 1

Null2

Collect[P[x] + Q[x], x]

-1 + d+ (c- f) x+ (b+e) x^ax3

Collect[P[x]*Q[x], x]

-d+ (-c-df) x+ (-b+de- cf) x2* (-a+ ce-bf) x3 +

(be-af) x4+aex5

{PolynomialQ[P[x]], PolynomialQ[Q[x]]}

{True, True}

PolynomialQ[Sin[x], x]

False

PolynomialQ[P[x] + Q[x]]

True

Decompose[P[x], х]

{d+ cx+ bх2 + ах3}

PolynomialQuotient[P[x], Q[x], x]

b/e+af/e2+ax/e

PolynomialRemainder[Q[x], Р[х], х]

-1-fx+ex2

CoefficientList[P[x], x]

{d, с, b, a}

Decompose[х^6 + х + 1 - х^3 + 2*х^5, х]

{1+х-х3+2х5 + х6}

PolynomialGCD[Р[х], Q[х]]

1

PolynomialLCM[P[x], Q[x]]

Р[х] Q[x]

PolynomialQuotient[3*x^3 - 2*х^2 + х, х^2 - х + 1, х]

1+Зх

PolynomialRemainder[3*х^3 - 2*х^2 + х, х^2 - х + 1, х]

-1-х

Reduce[а*х^2 + b*х + с == 0, х]

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

Функции для расширенных операций с выражениями

Выше была описана сравнительно немногочисленная группа функций для работы с выражениями — их упрощения, расширения, выделения множителей и т. д. Эти функции способны решать большинство повседневных задач, связанных с аналитическими преобразованиями выражений. Однако система Mathematica имеет гораздо более полный набор функций для работы с выражениями. Они приведены в приложении.

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

Apart [expr] — переписывает рациональное выражение expr в виде суммы членов с минимальными знаменателями; Apart [expr, var] — аналогична Apart [expr], но все переменные, кроме var, интерпретируются как константы. Примеры использования функции Apart:

Apart[(x^4 + 1)/(х^2 - 1)]

1+-1/(1+X)+X2-1/(1 + х )

Apart[(х^3 - у^3 - 1)/(х^2 - у), у]

Две уже знакомые нам функции выделяют знаменатель и числитель выражения в виде дроби:

Denominator[(х^2 - х - 1)/(х - 1)]

-1 + х

Numerator[(х^2 - х - 1)/(х - 1)]

-1-х + х2

Следующие функции позволяют судить о размерности выражений:

Depth [expr ] — возвращает значение, на единицу превышающее максимальное число индексов, требуемых для указания любой части выражения expr; Dimensions [expr] — возвращает список размерностей выражения expr; Dimensions [expr, n] — возвращает список размерностей expr до уровня n. Примеры применения этих функций:

Depth[х^3 + х^2 + х + 1]

3

Dimensions[х^3 - 2*х^2 + 1]

{3}.

Функция Evaluate [expr] вычисляет выражение expr безусловно, то есть даже если оно оказывается аргументом функции, чьи атрибуты определяют его невычисляемым:

Evaluate[1 + 1 + Sin[l]]

2+Sin[l]

 

Что нового мы узнали

В этом уроке мы научились:

Записывать выражения в разной форме. Работать с частями выражений. Осуществлять выделения и подстановки в функциях. Работать с рекурсивными функциями. Задавать инверсные функции. Задавать математические отношения. Упрощать, раскрывать и расширять выражения. Преобразовывать тригонометрические выражения. Работать с полиномами.

 

---

---