• Первое знакомство с системой Maple V R5
  • Построение двухмерного графика заданной пользователем функции
  • Пример построения графика поверхности
  • Управление мышью
  • Символьные вычисления
• Основные элементы интерфейса
  • Панели инструментов и форматирования
  • Строка меню
  • Электронные таблицы
  • Справочная система
• Выражения и основы работы с ними
  • Основы синтаксиса языка Maple
  • Последовательности, наборы и списки выражений
• Типы данных
  • Числа и строки
  • Системные константы и переменные
  • Данные множественного типа
• Операторы и операнды
• Встроенные функции
  • Элементарные и числовые функции
  • Специальные математические функции
  • Функции для работы с векторами и матрицами
  • Функции для работы со строковыми данными
• Типовые средства программирования
  • Функции пользователя
  • Условные выражения
  • Циклы for, while и do
  • Инструкции пропуска и прерывания
  • Простейшие процедуры
  • Инструкция возвращения значения
  • Функция вывода сообщений об ошибках
  • Общая форма задания процедуры
  • Средства контроля и отладки процедур
• Операции ввода и вывода
• Операции математического анализа
  • Вычисление сумм и произведений членов ряда
  • Вычисление производных
  • Вычисление интегралов
  • Вычисление пределов функций
  • Разложение функций в ряд
  • Вычисление асимптотических и иных разложений
  • Полиномиальная интерполяция данных
  • Сплайн-интерполяция и аппроксимация
  • Решение линейных и нелинейных уравнений
  • Решение систем нелинейных и трансцендентных уравнений
  • Функция RootOf
  • Решение неравенств
  • Решение функциональных уравнений
  • Решение в численном виде
  • Решение рекуррентных и иных видов уравнений
  • Решение дифференциальных уравнений
  • Структура неявного представления ДУ
  • Исследование аналитических функций
  • Кусочные функции
  • Прямое и обратное Z-преобразования
• Основные операции с выражениями
• Функции приложения и подстановки
• Упрощение выражений
• Расширение выражений
• Факторизация выражений
• Комплектование по степеням
• Операции с полиномами

Maple V R5 — система компьютерной алгебры, рассчитанная на выполнение самых сложных расчетов. Ее основой является ядро системы, содержащее около тысячи базовых функций. Имеется также основная библиотека операторов, команд и функций и ряд пакетов расширения системы (packages). Дополнительные функции из них должны применяться после загрузки пакета с помощью команды with (name), где name — имя применяемого пакета.

После запуска системы появляется ее основное окно (рис. 8.1). Вначале оно пустое и имеет имя Untitled (1). Как показано на рис. 8.1, можно сразу приступать к выполнению вычислений.

Рис. 8.1. Окно системы Maple V R5 с примерами вычислений

Входные выражения и результаты их вычислений занимают отдельные ячейки, обозначаемые слева квадратными скобками. Длина их зависит от размера выражений — исходных (вопроса) и результатов вычислений. Знак > является приглашением к вводу математического выражения. Текстовая строка (сверху) знака > не имеет. Ввод выражений задается по правилам строчного редактирования с применением курсора ввода — мигающей вертикальной черты |. Знак фиксации конца входного выражения ; (точка с запятой) обеспечивает вывод результата на экран, а знак : (двоеточие) отменяет вывод. Эти знаки также являются разделителями при записи в одной строке нескольких выражений. Клавиши перемещения курсора позволяют перемещаться по ранее введенным в сеансе работы строкам. Строки целиком и частично могут копироваться в буфер обмена и извлекаться из него.

На рис. 8.1 показано применение ряда сложных встроенных функций для символьных вычислений — нахождения производной dif(f(x),x) и неопределенного интеграла Int(f(х),х). Первая функция (имя начинается со строчной буквы) является вычисляемой. А вот функции, имена которых начинаются с прописной буквы, называются инертными. Они не вычисляются, а обеспечивают близкую к естественной форму записи входного выражения. Это может потребоваться для визуализации вычислений.

В ячейках ввода выражения с такими функциями можно перевести к обычной математической форме. Для этого требуется установить курсор в нужную ячейку и щелкнуть на кнопке х на контекстной панели (Context Bar), которая будет описана позже. Самым распространенным оператором является оператор присваивания :=. Он используется для задания переменным конкретных значений, например а:=2; b:=3; с:=а+b; и т. д.

Здесь графический объект представлен переменной g, значение которой (график) выводится в строку вывода. Для этой строки показано контекстное меню, позволяющее форматировать график. Для построения графика математической функции f используется графическая функция plot(f, х=-15.. 15). Параметр х=-15.. 15 задает переменную, относительно которой строится график, а также область изменения значений этой переменной (в нашем случае от -15 до +15).

Столь же просто можно построить график трехмерной поверхности или даже двух пересекающихся поверхностей (рис. 8.3). Для этого используется графическая функция plot3d.

Реализации возможностей управления мышью в Maple V R5 уделено значительное внимание. Помимо обычных функций мыши (щелчки на кнопках, управление меню и выделение объектов, выражений и их частей) для управления состоянием ячеек можно использовать контекстное меню (см. рис. 8.2 и 8.3). Если щелчок правой кнопкой мыши выполняется в ячейке ввода, указанное меню имеет три команды (рис. 8.4):

В меню Help имеется команда Ballon Help. Если она включена (рядом с именем команды присутствует галочка), то при наведении указателя мыши на элементы интерфейса появляются всплывающие подсказки (см. рис. 8.1 — 8.4). Мышь может использоваться для выделения выражений в ячейках ввода, выделения самих ячеек или вращения графика мышью.

На рис. 8.4 под панелью инструментов показана уже упомянутая контекстная панель (Context Bar). Она названа так потому, что состав ее кнопок зависит от текущего состояния системы, то есть от контекста. Контекстная панель размещается под панелью инструментов (если она отображается). При вводе текста эта панель превращается в стандартную панель форматирования (см. рис. 8.3, на котором она показана под панелью инструментов).

На рис. 8.1 был приведен ряд примеров на символьные вычисления, например на интегрирование с помощью функции int(f(x),x). В данном случае показана инертная форма этой функции Int(f (х), х) (см. рис. 8.1). При этом для вычисления выражения с инертной функцией используется функция value(%). На рис. 8.4 были приведены дополнительные примеры — решение системы линейных уравнений и квадратного уравнения с помощью функции solve. В дальнейшем мы познакомимся с возможностями системы в области символьных вычислений и графики более подробно.

Интерфейс пользователя Maple V R5 в основном обычен для систем компьютерной математики (см. главу 5). Назначение кнопок панели инструментов показано на рис. 8.5.

Командой Context Bar (контекстная панель) можно вывести еще один важный элемент интерфейса — контекстную панель. Она может иметь различный вид. Например, при вводе текста (см. рис. 8.3) она почти идентична панели форматирования Word, а при вводе математических выражений (см. рис. 8.4) отчасти напоминает панель формул Excel.

Другое полезное средство для облегчения работы по форматированию текстов, входных математических выражений и графиков — контекстные меню, появляющиеся при щелчке на объекте правой кнопкой мыши (см. рис. 8.2-8.4). Строка состояния обычна для Windows-приложений. Она отображает полезную и оперативную информацию — прежде всего о текущем времени и использовании памяти, а также о характере работы с системой. Команды меню View позволяют отобразить или скрыть любую из панелей или строку состояния.

Основным способом ввода математических выражений является их набор в ячейках ввода с помощью строкового редактора. Однако в меню View есть команда Palettes позволяющая вывести три палитры математических символов.

Следует отметить, что палитры математических символов имеются только в реализации Maple V R5. Предшествующие версии этих палитр не имеют.

Строка меню системы Maple V R5 традиционна для систем компьютерной математики (см. главу 5). Новым в реализации R5 является меню Spreadsheet, команды которого обеспечивают работу с электронными таблицами. Если все документы закрыты, то в строке меню имеется только две позиции — File и Help. При этом место для окон документов пусто и окрашено в серый цвет. Работа с меню не имеет каких-либо новых особенностей.

В Maple V R5 для задания электронных таблиц в меню Insert появилась команда Spreadsheets (вставка шаблона электронной таблицы). При ее выборе появляется типичный шаблон электронной таблицы. В ячейки таблиц могут вводиться символьные и числовые данные. При работе с таблицами контекстная панель приобретает новые кнопки, с назначением которых можно ознакомиться по всплывающим подсказкам.

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

В меню Spreadsheets имеются следующие команды:

Возможности Maple V R5 по обработке табличных данных значительно превосходят возможности обычных программ электронных таблиц (см. главу 2). Так, имеются принципиально новые возможности работы с символьными данными в ячейках таблицы.

Обратите внимание на запись интеграла в строке формул и в самой таблице. Например, для записи инертной формы интеграла в строку формул надо ввести следующую запись: Int(exp(x)* ^~A5, x). Это означает задание вывода интеграла с подынтегральной функцией в виде е^х, умноженной на содержимое ячейки А5 (А — имя столбца, 5 — номер строки). Таким образом, А5 — это адрес ячейки, из которой (указано символом ^~) выбирается заданное выражение. Выбрав команду для выполнения этой ячейки (или для всей таблицы), можно получить выражения в следующих двух позициях справа от выбранной ячейки.

Maple V R5 имеет две взаимосвязанные справочные системы. Помимо команд меню Help можно вызвать нужную справку в режиме командной строки, введя слово help или знак ? (например, help sin или ? sin). В данном случае после нажатия клавиши Enter будет получена справочная информация о функции sin (рис. 8.6). Такое обращение применяется для библиотечных функций и зарезервированных (ключевых) слов.

Рис. 8.6. Пример получения справки о функции sin

Чтобы получить помощь по функциям пакета расширения системы plots, достаточно ввести в командной строке имя пакета после вопросительного знака, например ?plots. А чтобы найти полный перечень пакетов расширения, можно ввести команду ?packages. Удобно в описываемой версии Maple V R5 решен и вопрос о предоставлении оперативной помощи по любой функции. Достаточно установить на имени функции курсор (или выделить его) и нажать клавиши Ctrl+F1.

Окно справочной системы в режиме поиска по контексту имеет пятиступенчатый уровень. Это позволяет постепенно уточнять понятие, по которому требуется получить подсказку. Например, поиск описания функции sin осуществляется по цепочке понятий: Mathematics — Basic Mathematics — Exponential, Trig and Hyperbolic functions — sin.

К наиболее важным знакам алфавита Maple, помимо общепринятых, относятся следующие.

Зарезервированные слова используются для создания условных выражений, циклов, процедур и управляющих команд. Это следующие слова: !, #, ERROR, assignment, break, by, do, done, elif, else, empty, fi, for, from, function, if, in, next, od, proc, quit, read, restart, save, separator, stop, then, while.

К зарезервированным относятся также слова, используемые при работе с множествами (intersect, minus, union), логические операторы (and, not и or) и оператор модуля mod. Зарезервированные слова имеют особый статус. Их нельзя использовать в качестве идентификаторов для переменных, функций, процедур и т. д.

Понятие выражения (ехрr) — центральное в языке Maple. Выражения вводятся в строку ввода. Ввод фиксируется нажатием клавиши Enter. При этом курсор ввода может быть в любой позиции строки. Если надо перенести ввод на новую строку, следует нажимать клавиши Shift+Enter. Ниже представлен пример ввода и упрощения выражений с помощью функции Simplify:

> simplify(sin(x)^2+cos(x)^2); #Упрощение выражения
                    1
> simplify((a^2-2*a*b+b^2)/(a-b));
                    а - b

Встречая выражение, Maple V R5 оценивает его, то есть устанавливает возможность вычисления выражения. Для оценки выражений служит функция evalf (expr, n). Она вычисляет выражение (ехрr) и возвращает вычисленное значение в форме действительного числа, имеющего n цифр после десятичной точки (по умолчанию 10). Есть ряд и других функций этого рода (см. примеры ниже):

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

Maple V R5 может работать как с одиночными выражениями, так и с их последовательностями. Они представляются рядом выражений, разделенных запятыми, и завершенным фиксатором:

> 1, 2+3, a-b, sin(1.0);
                    1, 5, а - b, .8414709848

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

> {d, а, с, а, а, с, d, е};
                    {d, а, с, е}
> {1+2,3,5,2+3,6};
                    {3, 5, 6}
> {'Hello','my','friend!'};
                    {friend!, Hello, my}

Отличительная черта наборов — автоматическое устранение из них повторяющихся по значению элементов. Кроме того, Maple может переставлять элементы наборов. Для создания упорядоченных наборов — списков — служат квадратные скобки []:

> [d,а,с,а,а,с,d,e];
                    [d, а, с, а, а, с, d, е]
> [1+2,3,5,2+3,6];
                    [3, 3, 5, 5, 6]
> ['Hello','my','friend!'];
                    [Hello, my, friend!]

Списки широко применяются для задания векторов и матриц. Для создания парных списков (например, координат точек (х,у) графика) используется функция zip(f, u, v) или zip(f, u, v, d), где f — бинарная функция; u,v — списки или векторы; d — необязательное значение. Примеры применения функции zip даны ниже:

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

Maple V R5 работает со всеми типами чисел. Число выводимых после десятичной точки цифр задает системная переменная Digits:

Возможна работа с числами, имеющими различное основание (base), в частности с бинарными числами (основание 2 — binary), восьмеричными (основание 8 — octal) и шестнадцатеричными (основание 16 — hex). Функция convert позволяет легко преобразовывать форматы чисел:

> х:=12345;
                    х := 12345
> b:=convert(x,binary);
                    b := 11000000111001
> o:=convert(x,octal);
                    o := 30071
> h:=convert(x,hex);
                    h := 3039
> convert(h,decimal,hex);
                    12345
> convert(o,decimal,octal);
                    12345

Помимо приведенных форм функция convert имеет ряд других форм (см. справочную систему). Функция type(x, numeric) позволяет выяснить, является ли переменная х числовой константой. Если да, то функция возвращает логическое значение true (истина), а если нет, то false (ложь). Функции type(x, integer) type(x, racional) и type(x, fraction) можно использовать для оценки того, имеет ли переменная х значение, соответственно, целого числа, рационального числа или простой дроби.

Последовательность символов рассматривается как строка, если она заключена в обратные апострофы, то есть символы '. Два апострофа подряд формируют апостроф как один из знаков символьной строки, например, 'abc''def' дает строку abc'def. Кроме того, любой текст строки после знака # рассматривается как невыводимый комментарий:

> 2+3; # Это пример 4+5;
                    5

Есть также ряд констант, которые правильнее считать заведомо определенными глобальными переменными: false — логическое значение “ложь”; gamma — константа Эйлера, равная 0,5772156648...; infinity — положительная бесконечность (отрицательная задается как -infinity); true — логическое значение “истина”; Catalan — константа Каталана, равная 0,915965594...; FAIL — специальная константа (см. ?FAIL в справочной системе); I — мнимая единица (квадратный корень из -1) и Pi — константа π=3,141... Для основания натурального логарифма надо использовать выражение ехр(1). Оно отображается как жирная прямая буква е. А ехр(1.0) выводит это число как вещественное.

Функции type(x, constant) и type(x, realcons) возвращают логическое значение true, если х представляет целочисленную или вещественную константу, и false, если х не является константой. Таким образом, эти функции можно использовать для идентификации констант, например:

Имена встроенных констант (как и имена функций) защищены специальным атрибутом protected. Поэтому (без его снятия) константам нельзя присваивать какие-либо значения. Тип глобальных переменных в системе Maple V R5 определяется присвоенным им значением. Для явного указания типа переменных используется конструкция name::type, где name — имя (идентификатор) переменной, type — тип переменной, например, целочисленный integer, вещественный с плавающей точкой float, со значением >=0 nonneg, комплексный complex и т. д. Помимо обычного задания имен переменных, они могут задаваться внутри знаков апострофа:

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

Нередко возникает необходимость отменить присвоенные переменным значения. Для этого можно заключить имя переменной в одинарные кавычки, например х:='х'. Можно сделать переменную х неопределенной и с помощью выражения вида x:=evaln(x). Для отмены присваивания значений разом всем переменным (и всех определений) можно использовать инструкцию restart.

Для придания переменным статуса предполагаемых используется инструкция assume(x, prop), где х — переменная, имя или выражение, prop — свойство:

> restart;
> assume(x, positive);
> х;
                    х^~
> s:=x->sqrt(x);
                    s := sqrt
> s(2.);
                    1.414213562
> s(-2);
                    1/2
                    I 2
> is(x,positive);
                    true
> about(x);
Originally x, renamed x^~:
        is assumed to be: RealRange(Open(0), infinity)

Обратите внимание на то, что в этом примере переменная х помечена как положительная и при выводе сопровождается знаком тильды ^~, как бы предупреждая нас о ее особом статусе. Это не означает, что она не может принять отрицательное значение. Однако с помощью функции is можно убедиться в ее особом статусе и при необходимости программным путем исключить вычисления для х<0. Кроме того, о свойствах переменной можно узнать с помощью функции about (name). Если к уже имеющимся признакам надо добавить новые, используется функция additionally:

Важным типом данных являются списки (lists), создаваемые с помощью квадратных скобок:

• [1,2,3,4] — список из четырех целых чисел;

• [1.,2.34,5] — список из двух вещественных и одного целого числа;

• [а,b,'Привет'] — список из двух символов (переменных) и строковой константы;

• [sin(x), 2*cos(x), a^2-b] — список из трех математических выражений.

Для создания векторов (одномерных массивов) и матриц (двухмерных массивов) служит функция array[a..b,s1]. Она возвращает вектор с индексами от а до b и значениями в одномерном списке s1. В другой форме — аrrау[а..b,с..d,s2] — она возвращает матрицу с номерами строк от а до b, столбцов от с до d и значениями в двухмерном списке s2. Примеры задания вектора и матрицы представлены ниже:

• аrrау(1..3,[х,у,х+у]) — создание вектора с элементами х, у и х+у;

• аrrау(1..2,1..2,[[а,b],[с,d]]) — создание квадратной матрицы.

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

> table([12,34,5,x,y+z]);
table([
        3 = 5
        4 = х
        5 = y + z
        1 = 12
        2 = 34
        ])
> S[1];
                    S[1]
> S[three];
                    3
> S[one];
                    1
> entries(S);
                    [3], [2], [1]
> indices(S);
                    [three], [two], [one]

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

Maple V R5 имеет пять типов операторов: binary — бинарные операторы (с двумя операндами); unary — унарные операторы (с одним операндом); nullary — нульарные операторы (без операнда — это одна, две и три пары кавычек); precedence — операторы старшинства (включая логические операторы); functional — функциональные операторы. Для просмотра операторов и их свойств можно использовать команду ?operators[onepaтop], в которой оператор — указанный выше тип оператора.

Бинарные (инфиксные) операторы используются с двумя операндами. В ядро Maple V R5 включено около трех десятков бинарных операторов. Прежде всего, это арифметические операторы +, -, * и /. Отметим и наиболее важные другие бинарные операторы.

> 7 mod 5;
                    2
> 2**3;
                    8
> 3^2;
                    9
> 3@2;
                    3
> 3@@2;
                    (2)
                    3
> х@х;
                    (2)
                    х

Оператор композиции @@ может использоваться для создания сложных функции, содержащих цепные дроби. Бинарные операторы есть и для множеств: union — включает первый операнд (множество) во второй; intersect — создает множество, содержащее общие для операндов элементы; minus — исключает из первого оператора элементы второго оператора. В любом случае в результирующем множестве повторяющиеся элементы устраняются:

> {a,a,b,c,c,d} union {e,e,f,g};
                    {a, b, d, с, е, f, g}
> {a,a,b,c,c,d} intersect {a,c,e,f,f,g};
                    {a, c}
> {a,a,b,c,c,d} minus {a,d};
                    {b, c}

Унарные операторы используются с одним операндом. Это следующие операторы: +, -, ! (факториал), десятичная точка, $ (последовательность), not (логическое отрицание) и % (метка):

Конструкции с этими операторами, например х=у, возвращают логическое значение t rue, если условие выполняется, и false, если оно не выполняется. Кроме того к логическим относится унарный оператор not — он представляет логическое отрицание. Для возврата логических значений выражений с этими операторами используется функция еvalb(условие), например:

Операторы в Maple V R5 описывают операции по преобразованию данных, в частности выражений. В свою очередь их можно отнести к данным абстрактного типа. Могут быть описаны следующие типы операторов: неопределенные (f); нейтральные (&); процедурные; функциональные; композиционные (@). Из них отметим функциональные операторы. Они являются альтернативами функций и записываются в форме vars -> result.

Maple V R5 имеет полный набор элементарных математических функций. Для получения подробной информации о некоторой произвольной функции f достаточно ввести команду ?f. В теории чисел используются функции: factorial(n) — факториал (альтернатива — оператор !); iquo(a, b) — частное для a/b; irem(a, b) — остаток для a/b; igcd(a, b) — наибольший общий делитель; lcm(a, b) — наименьшее общее кратное. Их применение очевидно.

В Maple R5 входит обширный набор специальных математических функций: AiryAi (Bi) — функция Айри; AngerJ — функция Ангера; bernoulli — числа и полиномы Бернулли; Bessell (J, К, Y) — функции Бесселя разного рода; Beta — бета-функция; binomial — биноминальные коэффициенты и др. Примеры применения трех таких функций даны ниже:

Элементы векторов и матриц являются индексированными переменными, то есть место каждого элемента вектора определяется его индексом, а у матрицы — двумя индексами. Обычно их обобщенно обозначают как i (номер строки матрицы или порядковый номер элемента вектора) и j (номер столбца). Допустимы операции вызова нужного элемента и присваивания ему нового значения:

> V:=array(1..3,[1,2,3]);
                    V  := [1,   2,   3]
> V[1]:=a:V[3]:=b:
> evalm(V);
                    [a,   2,   b]
> M:=array(1..3,1..3,[[a,b,c],[d,e,f],[i,k,l]]);
                         [a   b   c]
                    M := [d   e   f]
                         [i   k   l]
> М[2,2]:='Привет':
> evalm(M);
                    [a   b       c]
                    [d   Привет  f]
                    [I   k       l]
> M[3,2];
                    k
> M[2,2];
                    Привет
> type(V,vector);
                    true
> type(M,vector);
                    false
> type(M,matrix);
                    true

В этих примерах применены следующие функции для работы с векторами и матрицами: evalm(M) — эволюция матрицы M; type(V,vector) — тестирование вектора V и возвращение true, если V — вектор, и false в ином случае; type(M,matrix) — тестирование матрицы М и возвращение true, если М — матрица, и false в ином случае. К векторным и матричным функциям можно также отнести функцию преобразования convert с параметрами vector и matrix:

Напоминаем, что строковые данные представляются совокупностью любых символов в апострофах, например 'Привет' или '2+2'. Для контроля объектов на принадлежность к строковым данным служит функция type с параметром string. Для интерактивного ввода строк можно использовать функцию readline():

> s:=readline();
> Привет, мой друг!
                    s := Привет, мой друг!

Есть также возможность интерактивного ввода с помощью функции readstat(promt), где promt — строка с текстовым комментарием:

> y:=readstat('Введите выражение');
> а*х^2+b;
                    2
                    у := ах + b

Помимо отождествления выражения с переменной, например m:=sqrt(x^2+y^2), полноценную функцию пользователя в Maple V R5 создают в виде конструкции: name:=(x,y, ...) -> expr. После этого вызов функции осуществляется в виде name(х,у, ...), где (х,у, ...) — список формальных параметров функции пользователя с именем name. Переменные, указанные в списке формальных параметров, являются локальными:

> restart:
> х:=0;у:=0;
                    х := 0
                    у := 0
> m:=(x,y)->sqrt(x^2+y^2);
                    2    2
                    m := (x, у) -> sqrt(x + у)
> m(3,4);
                    5
> m(3.,4.);
                    5.000000000
> x;y;
                    0
                    0

Еще один способ задания функции пользователя базируется на применении функции unapplay(expr, var1, var2, ...):

> fm:=unapply(sqrt(x^2+y^2),x, у);
                    2   2   1/2
                    fm := (x, y) -> (x + у)
> fm(4.,3.);
                    5.000000000
> fe:=unapply(x^2+y^2,x,y);
                    2    2
                    fe := (x, y) -> x + у
> fe(sin(x), cos(x));
                    2    2
                    sin(x) + cos(x)
> simplify(fe(sin(x),cos(x)));
                    1

Для подготовки разветвляющихся программ в язык программирования Maple включена инструкция if, позволяющая создавать следующую конструкцию:

if <Условие сравнения> then <Выражения>
|elif <Условие сравнения> then <Выражения>|
|else <Выражения>|
fi;

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

В условиях используются любые логические конструкции с операторами сравнения (<, <=, >, >=, =, <>) и логические операторы and, or и not, конструкции с которыми возвращают логические значения true и false. Простые примеры ниже иллюстрируют применение логических операторов:

> х:=-5:
> if x<0 then print('Negative') else print('Positive') fi;
                    Negative
> x:=1:
> if x<0 then print('Negative') else print('Positive') fi;
                    Positive

Циклы for в MapleV R5 задаются обобщенной конструкцией

Здесь name — имя управляющей переменной цикла; expr1, expr2 и ехрr3 — выражения, задающие начальное значение, конечное значение и шаг изменения переменной name; expr4 — выражение, задающее условие выполнения цикла. Изменение переменной цикла i можно проследить в следующих примерах:

Эта конструкция цикла в языке программирования Maple вобрала в себя основные конструкции циклов for и while. Есть еще одна более специфическая конструкция цикла:

Здесь expr1 задает список значений, которые будет принимать управляющая переменная name. Цикл будет выполняться, пока не будет исчерпан список и пока выполняется условие, заданное выражением ехрr2. Следующие примеры иллюстрируют сказанное:

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

Здесь выражения statseq выполняются, пока выполняется логическое условие ехрr:

В этом примере идет удвоение числа n с начальным значением n=1 до тех пор, пока значение n меньше 16.

Иногда бывает нужным пропустить определенный цикл. Для этого используется инструкция next (следующий). Приведенный ниже пример иллюстрирует применение инструкции next в составе инструкции if-fi для исключения вывода значения i=-2:

Другая инструкция — break — прерывает выполнение фрагмента программы (или цикла), как только встречается в ходе ее выполнения. Действие инструкции поясняет слегка модифицированный предыдущий пример:

Любая из инструкций quit, done или stop обеспечивает также прерывание выполнения текущей программы (в частности, цикла) с закрытием окна и удалением сделанных определений.

Простейшая форма задания процедуры с локальными параметрами (переменными) в Maple следующая:

name := рrос(параметры)
        Тело процедуры
end;

Параметры процедуры задаются перечислением имен переменных, например рrос(х) или рrос(х,у,z). С помощью оператора :: после имени переменной можно определить ее тип, например, в объявлении prog(n::integer) объявляется, что переменная n является целочисленной. При вызове процедуры выражением вида namе(фактические_параметры) фактические параметры подставляются на место формальных:

Нетрудно заметить, что при знаке ; после завершающего слова end текст процедуры повторяется в строке вывода (в общем случае в несколько ином виде). Если это повторение не нужно, после слова end надо выставить знак двоеточия.

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

Параметром RETURN может быть любое выражение. Для предотвращения побочных эффектов Maple V R5 автоматически вставляет ключевое слово local для объявления глобальных переменных локальными и выдает предупреждающее сообщение о подобном применении:

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

При профессиональной подготовке процедур пользователь должен предусмотреть поведение процедуры при возможных ошибках, что реализуется с помощью различных функций оценки и тестирования. При выявлении ими ошибки обычно предусматривается вывод соответствующего сообщения. Для этого используете функция ERROR(expr_1, ехрr_2, . . .), где ехрr_1,... — ряд выражений (возможно, пустой). Наиболее часто ERROR выводит просто строковое сообщение об ошибке, например ERROR('strings'). Полное сообщение об ошибке имеет вид

name:=proc(<argseq>)         # объявление процедуры
    local<nseq>;             # объявление локальных переменных
    global<nseq>;            # объявление глобальных переменных
    options<nseq>;           # объявление ключей
    description<stringseq>;  # объявление комментария
    <stateq>                 # выражения — тело процедуры
end; (или end:)              # объявление конца процедуры

Эта команда обеспечивает полный вывод текста процедур библиотеки. Встроенные в ядро процедуры, написанные не на языке Maple, в полном тексте не представляются, например:

Одним из средств отладки процедур является функция трассировки trace (name). Детальность ее работы задается системной переменной printlevel, определяющей уровень вывода. Действие функции трассировки отменяется инструкцией untrace. При отладке алгоритмов выполнения вычислений надо тщательно следить за сообщениями об ошибках. Для этого в Maple предусмотрены функция traceerr и системная переменная lasterr, в которой сохраняется последнее сообщение об ошибке. При каждом обращении к traceerr переменная lasterr очищается.

Для иллюстрации работы с интерактивным отладчиком (debugger) составим некоторую процедуру demo, вычисляющую сумму квадратов чисел (1^2+2^2+...+n^2):

> demo:=proc(n::integer) local y,i: y:=0: for i to n do y:=y+i^2 od end;
demo := proc(n::integer)
local y, i;
        у := 0; for i to n do у := у + i^2 od
end
> demo(3);
                    14

Чтобы запустить отладчик, надо исполнить команду stopat:

> stopat(demo);
                    [demo]
> demo(3);
demo:
                    1*     у := 0;
DBG> next

Признаком, указывающим на работу отладчика, является изменение приглашения к вводу со знака > на DBG> (как нетрудно догадаться, DBG означает debugger). Теперь, вводя команды next (следующий), step (шаг) и stop (остановка), можно проследить выполнение процедуры:

0
demo:
        2           for i to n do
od
DBG> step
0
demo:
        3           у := y+i^2
DBG> step
1
demo:
        3           у := у+i^2
DBG> step 5
demo:
        3           у := y+i^2
DBG> step
                    14

> showstat(demo);
demo := proc(n::integer)
local у, i:
        1           У := 0;
        2           for i to n do
        3           у := y+i^2
                    od
end

Для записи на магнитный диск программных модулей используются инструкции save filename — запись всех определений текущего файла под именем filename; save name_1, name_2, ..., name_k; filename — запись избранных модулей с указанными именами. Считывание имеющегося на диске файла с именем filename осуществляется инструкцией read<filename>. Для загрузки файлов с расширением *.m из стандартной библиотеки используется функция readlib. А для записи файлов в качестве библиотечных достаточно в имени filename инструкции save указать расширение . m. Разумеется, можно считывать такие файлы и инструкцией read, указав в имени файла расширение .m:

> save my_proc,'my_lib.m': # запись файла mу_рrос и библиотечного файла
my_lib.m;
> load 'my_lib.m': # считывание библиотечного файла my_lib.m.

Обмен информацией между Maple V R5 и внешней средой (к ней, кстати, относятся и другие программы) чаще всего осуществляется через файлы текстового формата, поскольку именно с такими файлами работают практически все программные средства. Для записи данных в файл служит инструкция writedata[APPEND](fileID, data). Есть еще две ее формы:

Здесь fileID — имя или дескриптор файла данных; data — список, вектор или матрица данных; format — спецификация формата данных (integer, float или string); default — процедура, задающая запись нечисловых данных. Необязательный указатель APPEND используется, если данные дописываются в уже созданный файл. Считывание из полученного файла с именем filename обеспечивает функция readdata(fileID, n), а также функции readdata(fileID, format, n) и readdata(fileID, format). Здесь n — целое положительное число, задающее количество считываемых столбцов. Ниже даны примеры на эти операции:

> В := аrrау( [[1.5,2.2,3.4],[2.7,3.4,5.6],[1.8,3.1,6.7]]);
                    [1.5    2.2    3.4]
                    [                 ]
               В := [2.7    3.4    5.6]
                    [                 ]
                    [1.8    3.1    6.7]
> writedata('C:\\mydata.txt',B);
> E:=readdata('С:\\mydata.txt' ,3);
    Е := [[1.5, 2.2, 3.4], [2.7, 3.4, 5.6], [1.8, 3.1, 6.7]]

Так, для подготовки выражений или файлов в формате LaTeX служит функция latex(expr, filename), пример применения которой дан ниже:

> latex(a*x^2+b*x+c);
a{x}^{2}+bx+c
> latex(diff(x^n,x$2));
{\frac {{x}^{n}{n}^{2}}{{x}^{2}}}-{\frac {{х}^{n}n}{{х}^{2}}}

Здесь f — функция, задающая члены суммируемого ряда; k — индекс суммирования; m и n — целочисленные пределы изменения k, alpha — RootOf-выражение. Значение n может приниматься бесконечным, тогда для n используется константа infinity. Ниже даны примеры на применение этих функций в вычисляемой форме:

Аналогичным образом для произведений членов f(i) некоторой последовательности используются следующие функции:

Для вычисления производных функций fⁿ(x)=dfⁿ(x)/dxⁿ n-го порядка Maple V R5 имеет следующие основные функции:

diff(a, х1, х2, ..., xn) diff(a, [x1, х2, ..., хn])
Diff(a, х1, х2, ..., xn) Diff(a, [x1, х2, ..., хn])

Здесь а — дифференцируемое алгебраическое выражение, в частности функция f(x1, x2, ...,хn) ряда переменных, по которым производится дифференцирование. Примеры вычисления производных:

> Diff(a*x^n,x)=diff(a*x^n,x);
                    n
                    d n        a x n
                    ---- a x = -----
                    dx           x
> diff(sin(x),x);
                    cos(x)
> diff([sin(x),x^n,exp(a*x)],x);
                    n
                    x n
                    [cos(x), ---, a exp(a x)]
                    x
> restart;
> f(x,y):=cos(x)*y^3;
                    3
                    f(x, y) := cos(x) у
> diff(f(x,y),x);
                    3
                    -sin(x) у
> diff(f(x,y),y);
                    2
                    3 cos(x) у
> diff(f(x,y),x,y);
                    2
                    -3 sin(x) у
> diff(f(x,y),x$4);
                    3
                    cos(x) у

Для создания функций с производными может также использоваться дифференциальный оператор D(f) или D[i](f), где параметр f — выражение или имя функции, i — положительное целое число, выражение или последовательность. Оператор D(f) просто вычисляет имя производной от f, поскольку в этой форме он эквивалентен unnaply(diff(f(x), x),x). В форме D(f)(x) этот оператор подобен diff(f(x),x). Ниже даны примеры применения дифференциального оператора:

В следующем примере показано дифференцирование функции пользователя fun с применением дифференциального оператора D и функции diff:

> f:=(x,y,z)->x*exp(y)+ln(z);
                    f := (х, у, z) -> x exp(y) + ln(z)
> D[1](f);
                    (x, y, z) -> exp(y)
> D[2](f);
                    (x, y, z) -> x exp(y)
> D[3](f);
                    (x, y, z) -> 1/z

Пример применения дифференциального оператора для функции f, заданной программным объектом — процедурой, представлен ниже:

Этот пример иллюстрирует реализацию схемы Горнера для полинома b степени n от переменной х. При этом применение оператора дифференцирования возвращает процедуру. Ряд интересных возможностей по вычислению производных предоставляет пакет расширения student, в котором, кстати, дифференциальный оператор переопределяется.

Для вычисления неопределенных и определенных интегралов Maple V R5 представляет следующие функции: int(f,x); int(f,x=a..b); int(f,x=a..b, continuous); Int(f,x); Int(f,x=a..b) и Int(f,x=a..b, continuous). Здесь f — подынтегральная функция; х — переменная, по которой выполняются вычисления; а и b — нижний и верхний пределы интегрирования; continuous — необязательное условие. Ниже приведены примеры на вычисление интегралов:

> int(sin(x)/x,x);
                    Si(x)
> int(a*x^n,x);
                    (n + 1)
                    х    а
                    --------
                    n + 1

> sum(int(x^i,x),i=1..5);
                    2 3 4 5 6
                    1/2 х + 1/3 х + 1/4 х + 1/5 х + 1/6 х
> int(sum(x^i,i=1..5),x);
                    2 3 4 5 6
                    1/2 x + 1/3 x + 1/4 x + 1/5 x + 1/6 x
> P(x):=a*x^3+b*x^2+c*x+d;
                    3 2
                    P(x) :=ax+bx+cx+d
> int(P(x),x);
                    4 3 2
                    1/4 a x + 1/3 b x + 1/2 с x + d x

В некоторых случаях Maple V R5 не в состоянии вычислить интеграл. Тогда система просто воспроизводит его. С помощью функций taylor и convert можно попытаться получить аналитическое решение в виде полинома, что демонстрирует следующий характерный пример:

> int(exp(x^4),x);
                    /
                    | 4
                    |ехр(х) dx
                    |
                    /
> convert(taylor(",x=0,10),polynom,);
                    5   9
                    х + 1/5 х + 1/18 х

Для вычисления определенных интегралов используются те же функции int и Int, в которых надо указать пределы интегрирования, например х=а..b, если интегрируется функция переменной х:

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

> int( 1/(х+а)^2, x=0..2, 'continuous' );
                    1
                --------- + 1/a
                  2 + а
> int(1/x^3, x=-1..2, 'CauchyPrincipalValue');
                    3/8

С помощью функций int и Int могут вычисляться кратные интегралы. Для этого функции просто используются неоднократно.

Для вычисления пределов функции f в точке х=а используются следующие функции: limit (f,x=a), Limit (f,x=a), limit (f,x=a,dir) и Limit(f,x=a,dir). Здесь f — алгебраическое выражений, х — имя переменной, dir — параметр, указывающий на направление поиска предела (left — слева, right — справа, real — в области вещественных значений и complex — в области комплексных значений). Примеры применения этих функций приведены ниже:

> Limit(1-exp(-x),x=infinity);
                    lim 1 - ехр(-х)
                    х -> infinity
> value(");
                    1
> limit(sin(x)^2,x=Pi/2);
                    1
> limit(exp(x), x=infinity);
                    infinity
> limit(exp(x), x=-infinity);
                    0
> limit(1/x, x=0, real);
                    undefined
> limit(exp(x~2)*(1-erf(x)), x=infinity);
                    0

Для разложения функции или выражения ехрr в ряд служат функции series(expr, eqn) и series(expr, eqn, n). Здесь ехрr — разлагаемое выражение, eqn —условие (например, х = а) или имя переменной (например, х, что эквивалентно х=0) и n — необязательное и неотрицательное целое число, задающее количество членов ряда (при отсутствии его оно по умолчанию берется равным 6, но может переустанавливаться системной переменной Order). Ниже представлены примеры разложения различных выражений в ряд:

Здесь видно, что член, дающий ошибку, отсутствует в тех разложениях, которые точны, — например, в разложениях степенных многочленов. Для разложения в широко распространенный ряд Тейлора используется функция taylor(expr, eq/nm, n), где ехрr — разлагаемое в ряд выражение, eq/nm — равенство (в виде х = а) или имя переменной (например, х), n — необязательный параметр, указывающий на порядок разложения и представленный целым положительным числом (при отсутствии указания порядка он принимается по умолчанию равным 6). При задании eq/nm в виде х=а разложение готовится относительно точки х=а. При указании eq/nm в виде просто имени переменной разложение ищется в окрестности нулевой точки, то есть фактически вычисляется ряд Маклорена. Ниже представлены примеры применения функции taylor:

> taylor(sinh(x),x,10);
                    3  5  7  9  10
                    х + 1/6 х + 1/120 х + 1/5040 х + 1/362880 х + 0(х)
> taylor(1/x+x^2,x,5);
Error, does not have a taylor expansion, try series()
> taylor(int(sin(x)/x,x),x);
                    3  5  6
                    x - 1/18 x + 1/600 x + 0(x)

Для разложения в ряд Тейлора функций ряда переменных используется функция mtaylor(f, v), mtaylor(f, v, n) или mtaylor(f, v, n, w). Здесь f — алгебраическое условие, v — список имен или равенств, n — необязательное число, задающее порядок разложения, и w — необязательный список целых чисел, задающих “вес” каждой переменной списка v. Эта функция должна вызываться из библиотеки Maple V R5:

> readlib(mtaylor);
> mtaylor(sin(x*y),[x,y],10,[2,1]);
                    proc() ... end
                    3 3
                    x у - 1/6 x у
> mtaylor(exp(-x)*sin(y),[x,y],5);
                    3 2 3 3
                    у - х у - 1/6 у + 1/2 х у + 1/6 х у - 1/6 х у

Для получения только коэффициента при члене k-ro порядка ряда Тейлора можно использовать функцию coeftayl(expr, var, k). Если ехрr — функция ряда переменных, то параметр k должен задаваться списком порядков коэффициентов.

Для вычисления асимптотических разложений функций (в виде рядов) используется функция asympt(f, х) или asympt(f, х, n), где f — функция переменной х или алгебраическое выражение; х — имя переменной, по которой производится разложение; n — положительное целое число (порядок разложения по умолчанию 6). Помимо указанных выше Maple V R5 имеет множество функций для иных разложений выражений в ряд. Так, в пакете расширения numapprox имеется Функция laurent(expr, var, n), позволяющая получить разложение в ряд Лорана, функция chebyshev(expr, eq/nm, eps) дает разложение в форме полиномов Чебышева и т. д.

Если данные некоторой зависимости у(х) заданы векторами X и Y ее дискретных значений, то для получения интерполяционного степенного полинома v можно использовать функцию interp(X, Y, v), или в инертной форме Interp(X, Y, v). В ней векторы X и Y должны содержать n+1 координат точек исходной зависимости, где n — степень интерполяционного полинома. Приведем примеры:

> Interp([2,5,6], [9,8,3], х) mod 11;
                    2
                    8 х+ 6 х + 9
> alias(alpha=RootOf(x^4+x+1));
                    I, alpha
>а := Interp([0,1,alpha],[alpha,alpha^2,alpha^3],x) mod 2;
                    2 2
                    a := x + (alpha + alpha + 1) x + alpha

Maple V R5 позволяет осуществлять сплайн-интерполяцию и аппроксимацию. Для получения сплайн-функции используется Maple-функция spline(X,Y,var,d), где необязательный параметр d задает вид сплайна (linear — линейная функция, quadratic — квадратичная функция или полином второго порядка, cubic — полином третьего порядка и quartic — полином четвертого порядка). Если параметр d опущен, то сплайн-функция будет строиться на основе полиномов третьего порядка (кубические сплайны). Технику сплайновой аппроксимации поясняет рис. 8.7.

Для решения линейных и нелинейных уравнений в аналитическом виде используется достаточно универсальная и гибкая функция solve(eqn, var) или solve ({eqn1,eqn2, . . .},{var1, var2, ...}), где eqn — уравнение, содержащее функцию ряда переменных, var — переменная, по которой ищется решение. В форме solve[subtopic] возможны расширения функции solve следующих типов: floats, functions, identity, ineqs, linear, radical, scalar, series и system.

При решении систем уравнений они и список переменных задаются как множества, то есть в фигурных скобках. При этом и результат решения получается в виде множества. Чтобы преобразовать его к обычному решению, нужно использовать функцию assign, которая обеспечивает присваивание переменным значений, взятых из множества. Функция solve пытается дать решение в аналитическом виде. Это не означает, что получить корни уравнений в численном виде не удастся. Просто для этого потребуется функция evalf или convert. Если результат решения представлен через функцию RootOf, то получить все корни можно с помощью функции allvalues.

Решение одиночных нелинейных уравнений вида f (х)=0 легко обеспечивается функцией solve(f(x),x):

> е1:={2*х^2+х+3=0};
                    2
                    е1 := {2 х + х + 3 = 0}
> s:=solve(e1,x);
                    1/2   1/2
                    s := {х = - 1/4 + 1/4 I 23}, {x = - 1/4 - 1/4 I 23}

В частности, это позволяет легко проверить решение (даже если оно не одно, как в приведенном примере) подстановкой subs:

Сводящиеся к одному уравнения вида f1(x)=f2(x) также решаются функцией solve(f1(x)=f2(x),x):

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

> solve(sin(x)=0.2,х);
                    .2013579208
> solve(sin(x)=1/2,x);
                    1/6 Pi
> evalf(");
                    .5235987758

Для получения периодических решений надо задать _EnvAllSolutions:=true;. Тогда можно получить.

> solve(sin(x)=1/2,x);
1/6 Pi + 2/3 Pi _В1^~ + 2 Pi _Z1^~

Функция solve может использоваться для решения систем нелинейных и трансцендентных уравнений. Для этого система уравнений и перечень неизвестных задаются в виде множеств:

> restart;
> solve({x*y=a,x+y=b},{x,y});
                    2   2
{у = RootOf(_Z - _Z b + a), x = -RootOf(_Z - _Z b + a) + b}
> allvalues(");
                    2   1/2    2   1/2
    {y = 1/2 b + 1/2 (b - 4 a), x = 1/2 b - 1/2 (b - 4 a)},
                    2   1/2   2   1/2
    {y = 1/2 b - 1/2 (b - 4 a), x = 1/2 b + 1/2 (b - 4 a)}
s:=solve({x*y=2,x+y=3},{x,y});
                    s := {y = 1, x = 2}, {y = 2, x = 1}
> assign(s);x; y;
                    1
                    2
> unassign('x');y:='y';
                    y := y
> x;у;
                    x
                    y

В этих примерах достаточно отчетливо видна техника работы с функциями solve и assign.

В решениях уравнений нередко появляется функция RootOf, означающая, что корни нельзя выразить в радикалах. Эта функция применяется и самостоятельно в виде RootOf(expr) или RootOf(expr, x), где ехрr — алгебраическое выражение или равенство, а х — имя переменной, относительно которой ищется решение. Если х отсутствует, ищется универсальное решение по переменной _Z. Когда ехрr задано не в виде равенства, решается уравнение ехрr = 0. Для получения решений в явном виде может использоваться функция allvalues. Примеры применения функции RootOf:

Итак, функция RootOf является эффективным способом представления решения в компактном виде.

Решение неравенств существенно расширяет возможности функции solve. При этом неравенства задаются так же, как и равенства:

> solve(5*x>10,x);
                    RealRange(Open(2), infinity)
> solve((x-1)*(x-2)/(x-3)<0,x);
      RealRange(-infinity, Open(1)), RealRange(Open(2), Open(3))
> solve(ln(x)>2,x);
                    RealRange(Open(exp(2)), infinity)
> solve(exp(x)*x>=1,x);
                    RealRange(LambertW(1), infinity)
> solve(a*x < b, {x});
                    signum(a) b
     {signum(a) x < -------------}
                        a
> solve({x*y*z>0,x>-1,y+z>10},{x,y,z});
      {10 < z, -1 < x, у = 0}, {10 < у, -1 < x, z = 0}

Для решения функционального уравнения можно использовать функцию solve:

> A:=solve(f(x)^2-x+1,f);
                    А:= proc(x) RootOf(_Z^2 - х + 1) end
> convert(A(x),radical);
                    1/2
                    (x - 1)
> B:=solve(f(x)*x=ln(x^2),f);
Error, (in solve/CancelInv) too many levels of recursion
> c:=solve(f(x)*x^2=a*x^2+b*x+c,f);
                    С := proc(x) (a*x^2 + b*x + c)/x^2 end
> convert(C(x),radical);
                    2
                    a x + b x + с
                  -----------------
                      2
                    x

Для получения численного решения нелинейного уравнения или системы нелинейных уравнений используется функция fsolve(eqns, vars, options) с параметрами: complex — находит один или все корни полинома в комплексной форме; fulldigits — вычисления выполняются для полного числа цифр, заданного функцией Digits; maxsols=n — находит только n корней; interval — задается в виде а..b, x = а..b или {х=а..b, у=с..d, ...} и обеспечивает поиск корней в указанном интервале. Примеры:

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

Для решения рекуррентных уравнений используются функции: rsolve(eqns, fcns), rsolve(eqns, fcns, 'genfunc'(z)) и rsolve(eqns, fсns, 'makeproc'). Здесь eqns — одиночное уравнение или система уравнений, fсns — функция, имя функции или множество имен функций, z — имя, генерирующее функциональную переменную. Примеры:

Приведем примеры на применение функций isolve и msolve:

> isolve({2*x-5=3*y});
                    {х = 4 + 3 _N1, у = 1 + 2 _N1}
> msolve({2*x-3*y=2,5*x+y=3},13);
                    {y = 12, х = 6}
> msolve({2*x-3*y=2,5*x+y=3},5);
                    (y = 3, х = 3}
> fsolve(f(a)=2,a);
                    1.817120593
> solve(BesselJ(0,x)=x^2,x);
                    2
                    RootOf(BesselJ(0, _Z) - _Z)
> allvalues(");
                    .8988768155
> fsolve(erf(x)=0.5,x);
                    .4769362762

Функции solve и f solve позволяют решать уравнения, содержащие интегралы и специальные математические функции.

Для решения системы простых дифференциальных уравнений (ДУ) — задачи Коши — используется функция dsolve(deqns, vars) или dsolve(deqns, vars, option). Здесь deqns — одно ДУ или система ДУ первого порядка с указанием начальных условий, vars — переменная или переменные, относительно которых ищется решение, и option — необязательный параметр, указывающий на метод решения (exact — аналитическое решение — принято по умолчанию; explicit — решение в явном виде; laplace — решение на основе преобразования Лапласа; series — решение в виде ряда с порядком, указываемым значением переменной Order; numeric — решение в численном виде).

Для решения задачи Коши в deqns надо включать начальные условия, а при решении краевых задач — краевые условия. Если будет найдено решение при числе начальных или краевых условий меньше порядка системы, то в решении появятся неопределенные константы вида _С1, _С2 и т. д. Они же могут быть при аналитическом решении системы, когда начальные условия не заданы. Если решение найдено в неявном виде, то в нем появится параметр _Т.

Производные при записи ДУ могут задаваться функцией diff, оператором D или апострофом. Выражение deqns должно иметь структуру множества и содержать помимо самой системы уравнений их начальные условия. На рис. 8.8 приведены примеры решения одиночных ДУ в аналитическом виде.

Если не удается получить символьное решение ДУ, можно найти решение в численном виде с помощью функции dsolve с параметром numeric или type=numeric. При этом решение возвращается в виде специальной процедуры, по умолчанию реализующей широко известный метод решения дифференциальных уравнений Рунге—Кутта—Фельберга порядка 4 и 5 (в зависимости от условий адаптации решения к скорости его изменения). Эта процедура называется rkf45 и символически выводится (без тела) при попытке решения заданной системы ДУ (рис. 8.10).

Рис. 8.10. Решение системы ДУ численным методом rkf45 с выводом графика решения

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

Еще один пример решения системы ДУ представлен на рис. 8.11. На этот раз на одном графике показаны зависимости у(х) и z(x), обеспечивающие полное решение заданной системы. При этом процедура имеет особый вид listprocedure, и для преобразования листа выходных данных в векторы решения Y и Z используется функция subs.

В список параметров функции dsolve можно явным образом включить указание на метод решения, например, параметр mathod=dverk78 задает решение методом Рунге—Кутта порядка 7 или 8. С помощью параметра abserr=aerr можно задать величину абсолютной погрешности решения, а с помощью параметра 'minerr' = mine — минимальную величину погрешности. В большинстве случаев эти величины, заданные по умолчанию, оказываются приемлемыми для большинства расчетов.

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

Пакет Detools позволяет строить и многие другие виды графиков, например решения систем ДУ, представленные в трехмерном пространстве.

Для неявного представления ДУ в Maple V R5 введена специальная структура DESol (ехрr, vars), где expr — выражение для исходной системы ДУ, vars — заданный в виде параметра список переменных (или одна переменная). Структура DESol образует некоторый объект, дающий представление о ДУ и чем-то напоминающий функцию RootOf. С этим объектом можно обращаться как с функцией, то есть его можно интегрировать, дифференцировать, получать разложение в ряд и вычислять численными методами. На рис. 8.12 показаны примеры применения структуры DESol.

Рис. 8.12. Примеры применения структуры DESol

Обратите внимание на последний пример — в нем структура DESol использована для получения решения ДУ в виде степенного ряда.

Исследование функции обычно заключается в определении координат ее особых точек и значений в этих точках. С помощью функции solve легко находятся значения независимой переменной х функций вида f(x) при f(x)=0. Библиотечная функция extrema(ехрг, constr, vars, 'nv') позволяет найти экстремум выражения ехрr при ограничениях constr и переменных var, по которым ищется экстремум. Найденные координаты точек экстремума присваиваются переменной 'nv'. Параметры vars и 'nv' могут отсутствовать. Ниже даны примеры на применение функции extrema:

> readlib(extrema):extrema(x*exp(-x),{},x,'s');s;
                    (exp(-1)}
                    {{x = 1}}
> extrema(sin(x)^2,{},x,'s');s;
                    {0, 1}
                    {{x = - 1/2 Pi}, {x =0}, {x = 1/2 Pi}}
> extrema(x+y/z, (x^2+y^2+z^2)=1, {x,y,z},'s'); s;
                    4   2   4   2
                    {max(1 - RootOf(_Z + 1), -1 + RootOf(_Z + 1)),
                    4   2   4   2
                    min(1 - RootOf(_Z + 1), -1 + RootOf(_Z + 1))}
                    4   3   4
                    {{y = RootOf(_Z +1), x = -1, z = RootOf(_Z + 1)},
                    4   3   4
                    {x = 1, у = -RootOf(_Z + 1), z = RootOf(_Z + 1)}}

Для поиска экстремумов выражений (функций) ехрr служат функции стандартной библиотеки: minimize(expr), maximize(expr), minimize(expr, vars), maximize(expr, vars), minimize(expr, vars, 'infinite' ), maximize(expr, vars, 'infinite'), minimize(expr, vars, ranges), maximize(expr, vars, ranges).

Эти функции могут разыскивать максимумы и минимумы функции как одной, так и ряда переменных — они указываются списком переменных vars. Параметр 'infinity' означает, что поиск минимума или максимума выполняется по всей числовой оси, а параметр ranges позволяет задавать пределы изменения переменных при поиске. Примеры на применение этих функций даны ниже:

Функция iscont(expr, x = a .. b) или iscont(expr, x = a .. b, 'closed') позволяет исследовать выражение expr в виде зависимости от переменной х на непрерывность. Если выражение непрерывно, возвращается логическое значение true, иначе — false. Параметр 'closed' показывает, что конечные точки должны также проверяться.

Другая функция, discont (f, x), позволяет определить точки, в которых нарушается непрерывность функции f(х). Она вычисляет все точки в пределах изменения х от -¥ до +¥ . Результаты вычислений могут содержать особые экстрапеременные с именами вида _Zn^~ и _NNn^~:

Многие операции, например интегрирования и дифференцирования, чувствительны к особенностям функций, в частности, к ее разрывам и особым точкам. Функция singular(expr, vars) позволяет найти особые (сингулярные) точки выражения expr, в которых она имеет разрывы. Список переменных указывать не обязательно. Примеры применения этой функции приведены ниже:

> readlib(singular):
> singular(x+y+1/(x), {x,y});
    {х = -infinity, у = у), {х = infinity, у = у},
    {у = -infinity, х = х}, {у = infinity, х = х},
    {х = 0, у = у}
> singular(ln(x)/(x^2-a));
                    2
                    {а = а, х = 0}, {а = х, х = х}
> singular(tan(x));
                    {х = _N Pi + 1/2 Pi}
> singular(1/tan(x));
                    {x = Pi _Z^~}
> singular(Psi(x*y),{x,y});
                    _NN - 1
              {x =----------, у = y}
                       y

Для создания кусочных функций Maple V R5 имеет функцию piecewise( cond_1, f_1, cond_2, f_2, ..., cond_n, f_n, f_otherwise), где f_i — выражение, cond_i — логическое выражение, f_otherwise — необязательные выражения. В зависимости от того или иного условия эта функция позволяет формировать ту или иную аналитическую зависимость.

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

Важно отметить, что созданная с помощью piecewise зависимость может участвовать в различных преобразованиях (на рис. 8.13 она дифференцируется по частям).

Прямое и обратное Z-преобразования задаются функциями: ztrans(f, n, z) - прямое преобразование функции f(n) в f(z) и invztrans(f, z, n) — обратное преобразование f (z) в f (n). Заметим, что прямое Z-преобразование базируется на соотношении ztrans(f(n),n,z) = sum(f(n)/z^n, n=0..infinity), представленном на языке Maple. Примеры на применение Z-преобразований представлены ниже:

Z-преобразования осуществляются функциями ядра и стандартной библиотеки. Maple позволяет осуществлять и ряд других интегральных преобразований, в частности Лапласа и Фурье, которые реализуются с помощью пакета расширения inttrans (интегральные преобразования).

Выражения обычно используются как сами по себе, так и в виде уравнений или неравенств. В последнем случае объекты с выражениями имеют левую и правую части. Для простейших манипуляций с выражениями полезны следующие функции: cost(expr) — возвращает число сложений и умножений в выражении ехрr (библиотечная функция); lhs(eqn) — выделение левой части уравнения, eqn; hs(eqn) — выделение правой части уравнения eqn; normal(expr) — нормализация (сокращение) выражения ехрr в виде дроби; numer(expr) — выделение числителя выражения ехрr; denom(expr) — выделение знаменателя выражения ехрr.

Выражения в Maple могут иметь ряд уровней. Для работы с ними служат функции: nops(expr) — возвращает число объектов первого уровня в выражении ехрr; ор(ехрr) — возвращает список объектов первого уровня в выражении ехрr; ор(n, ехрr) — возвращает n-й объект первого уровня в выражении ехрг. Ниже представлены примеры применения этих функций:

> nops(a+b/c);
                    2
> op(a+b/c);
                    а, b/с
> op(1,a+b/c);
                    а
> op(2,a+b/c);
                    b/c

Для преобразования форм выражений служит важная функция convert (ехрr, form, аrg3, ...). Здесь ехрr — любое выражение, form— наименование формы, аrg3, ... — необязательные аргументы:

> convert(123, binary);
                    1111011
> V:=convert([1,2,3,4],vector);
                    V := [1, 2, 3, 4]
> type(V,vector);
                    true
> convert([a,b,c,d], ' + ');
                    a + b + с + d
> f:= seq(x[i]^n, i=1..4);
                    n n n n
                    f := x[1], x[2], x[3], x[4]
> convert([f], '*');
                    n n n n
                    x[1]x[2]x[3]x[4]
> convert(1.23456789, fraction);
                    1356579
                    --------
                    1098829
> s := series(f,x,5);
                    3 4 5
                    s := - x - x - x + 0(x)
> convert(s, polynom); # Удаление члена с ошибкой
                    3 4
                    -x - x - x
> convert(sinh(x), exp);
                      1
   1/2 exp(x) - 1/2-------------
                    exp(x)
> convert(arcsinh(x), ln);
                    2 1/2
                    ln(x + (x + 1))
> convert(/binomial(m,n), factorial);
                        m!
                    ---------------
                     n! (m - n)!

Еще одной мощной функцией преобразования выражений является функция combine. Она обеспечивает объединение показателей степенных функций и преобразование тригонометрических и некоторых иных функций. Эта функция может записываться в трех формах: combine(f), combine(f, n) и combine(f, n, opt1, opt2, ...). Здесь f — любое выражение, множество или список выражений, n — имя, список или множество имен, opt1, opt2, ... — имена необязательных параметров. Примеры:

Выражения и их части в Maple V R5 рассматриваются как объекты. Для контроля за типом объектов служит функция whattype(object), которая возвращает тип объекта, например string, integer, float, fraction, function и т.д. Могут также возвращаться данные об операторах. С помощью функции type (object, t) можно выяснить, относится ли указанный объект к соответствующему типу t, например:

В случае соответствия типа объекта указанному (второй параметр) функция type возвращает логическое значение true, в противном случае — false.

Нередко бывает необходимо заменить некоторое подвыражение в заданном выражении на функцию от этого подвыражения. Для этого можно воспользоваться функцией applyop(f, i, e), которая прикладывает функцию f к i-му подвыражению выражения е, или функцией applyop(f, i, e, ..., xk, ...), которая прикладывает функцию f к i-му подвыражению выражения е с включением необязательных параметров xk. Ниже даны примеры применения этой функции:

> applyop(sin,2,а+х);
                    а + sin(x)
> applyop(f,1,g,2,a+b);
                    f(g, 2, a+b)
> applyop(f,(2,3},a+x+y);
                    a + f(x) + f(y)
> applyop(f,{1,2},x/y+z);
                    f(x/y) + f(z)
> applyop(f,2,p,x1,x2);
                    2
                    у + f(-2 y, x1, x2) - 3

Есть еще две функции, реализующие операции приложения, — map (fcn, exp r, arg2, ..., аrgn) и map2(fcn, arg1, expr, arg3, ..., argn). Здесь fcn —процедура или имя, ехрr — любое выражение, argi — необязательные аргументы fcn. Первая из этих функций позволяет приложить fcn к операндам выражения ехрr. Ниже даны примеры на использование функций map:

> f:=x->x^2;
                    2
                    f := x -> x
> map(f, [1,2,3]);
                    [1, 4, 9]
> map(f,[x,y,z]);
                    2 2 2
                    [x , у , z]
> map(x->x^n,[1,2,3]);
                    n n
                    [1, 2, 3]
> L:=[1,2,3,4];
                    L := [1, 2, 3, 4]
> map(proc(x,y) x*y+1 end, [1,2,3,4], 2);
                    [3, 5, 7, 9]
> map(int,L,x);
                    [x, 2 x, 3 x, 4 x]
> mар(F,[1,2,3],х,у,z);
                    [F(1, x, y, z), F(2, x, y, z), F(3, x, y, z)]

Из этих примеров нетрудно заметить, что если второй параметр функции mар — список, то функция (первый параметр) прикладывается к каждому элементу списка, так что возвращается также список. Функция mар2 отличается иным расположением параметров:

> map2(w,g,{a,b,c});
                    {w(g, с), w(g, a), w(g, b)}
> map2(op, 1, [a+b+i,c+d+k,e+f+l]);
                    [a, c, e]
> map2(op, 2, [a+b+i,c+d+k,e+f+l]);
                    [b, d, f]
> map2(op, 3, [a+b+i,c+d+k,e+f+l]);
                    [i, k, l]
> map2(diff,[sin(x),cos(x),x^n],x);
                          n
                        x n
    [cos(x), -sin(x), -------]
                        x

Заметим, что подобные операции Maple V R5 реализует и с рядом других функций. Ограничимся примерами на приложения с помощью функций сложения add, умножения mul и создания последовательностей seq:

Основные операции подстановки выполняют следующие функции: subs(x=a,е) - в выражении е замняет подвыражение х на подвыражение a; subs(s1, ...,sn,e) - в выражении е заменяет одни подвыражения на другие, выбирая их из списков s1, ..., sn вида х=а; subsop(eq1, eq2, ..., eqi, ..., eqn, e) — в выражении е заменяет указанные операнды eqi другими, заданными в правой части равенств eqi вида ni=ei, где ni — номер операнда, ei — выражение для замены. Все эти функции возвращают измененное после подстановки выражение:

> subs(a=b,a^2-2*a*b-b^2);
                    2
                    -2 b
> subs(a=2,b=1,a^2-2*a*b-b^2);
                    -1
> subs(a=x,b=y,c=z,[a,b,c]);
                    [x, y, z]
> subs(a=sin(x)^2,b=cos(x),a+b*b);
                    2 2
                    sin(x) + cos(x)
> subsop(1=x,a+b+c);
                    x + b + с
> subsop(3=x,a+b+c);
                    a + b + x
> subsop(1=x,2=x,3=x,a+b+c);
                    3 x
> subsop(2=x,a+b/c);
                    a + x
> subsop(2=sin(x),(1+cos(x))/b);
                    (1 + cos(x)) sin(x)
> subsop(1=sin(x),2=sin(x),(1/cos(x))/b);
                    2
                    sin(x)

> eqs:={x+y+z=6,y/x=z-1,z-x=2};
               eqs := {x + у + z = 6, у/х = z - 1, z - x = 2}
> res:=solve(eqs,{x,y,z});
               res := {z = -2, у = 12, x = -4}, {у = 2, z = 3, x = 1}
> subs(res,eqs);
                    {2 = 2, -3 = -3, 6 = 6}

В системе Maple V R5 функция упрощения используется в следующем виде: simplify (ехрr) — возвращает упрощенное выражение expr или повторяет его, если упрощение в рамках правил Maple VR5 невозможно; simplify(expr, n1, n2, ...) — возвращает упрощенное выражение expr с учетом параметров n1, n2, ... (в том числе заданных списком или множеством); simplify(expr, assume=prop) — возвращает упрощенное выражение expr с учетом всех условий.

В функцию simplify можно включать необязательные параметры. Параметрами могут быть имена специальных математических функций и указания на область действия упрощений: BesselI, BesselJ, BesselK, BesselY, Ei, GAMMA, RootOf, LambertW, dilog, exp, ln, sqrt, polylog, pg, pochhammer, trig (для всех тригонометрических функций), hypergeom, radical, power и atsigm (для операторов). Полезен также параметр symbolic, указывающий на проведение символьных преобразований. Возможно также применение функции simplify в форме simplify[<name>], где <name> — одно из указаний: atsign, GAMMA, hyper-geom, power, radical, RootOf, sqrt, trig. Ниже даны примеры на применение функции simplify:

> simplify(exp(a+ln(b*exp(c))));
                    b exp(a + с)
> simplify((x^a)^b+4^(1/2), power);
                    (a b) 1/2
                    x + 4
> simplify(exp(a+ln(b*exp(c))));
                    b exp(a + c)
> simplify(sin(x)^2+cos(x)^2, trig);
                    1
> e := cos(x)^5 + sin(x)^4 + 2*cos(x)^2 - 2*sin(x)^2 - cos(2*x):
> simplify(e);
                    5 4
                    cos(x) + cos(x)
> simplify(ln(exp(2)),ln);
                    2
> simplify(GAMMA(n+4)/GAMMA(n),GAMMA);
                    n (n + 1) (n + 2) (n + 3)
> r := RootOf(x^2-2=0, x):
> simplify(r^2, RootOf);
                    2
> simplify(1/r, RootOf);
                    2
                    1/2 RootOf(_Z - 2)
> simplify(ln(x*y), power, symbolic);
                    ln(x) + ln(y)
> e:= (-5*b^2*а)^(1/2);
                    2 .1/2
                    e := (-5 b a)
> simplify(e,.radical);
                    1/2 2 1/2
                    5 (-b a)
> simplify(e,radical,symbolic);
                    1/2 1/2
                    b 5 (-a)
> simplify((t^2)^(1/2),sqrt,symbolic);
                    t

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

> restart;
> simplify(sqrt(x^4*y^2));
                    4 2 1/2
                    (х у)

> simplify(sqrt(x^4*y^2),assume=real);
                    2
                    x signum(y) у
> simplify(sqrt(x^4*y^2),assume=positive);
                    2
                    х у

Если функция simplify не способна выполнить упрощение выражения ехрr, она просто его повторяет. Это сигнал к применению параметров.

Функция expand расширяет выражение ехрr и записывается в виде expand(expr, ехрr1, ехрr2, ..., ехрrn), где ехрr — расширяемое выражение, ехрr1, ехрr2, ..., ехрrn — необязательные подвыражения. Имеется также инертная форма данной функции Expand(expr). Кроме того, возможно применение операторной конструкции frontend(expans, [ехрr]). Функция expand раскладывает рациональные выражения на простые дроби, полиномы на полиномиальные разложения, способ-на раскрыть многие математические функции, в том числе специальные. С помощью необязательных аргументов ехрr1, ехрr2 ..., ехрrn можно задать расширение отдельных фрагментов в выражении ехрr. Примеры на применение функции expand приведены ниже:

> expand((x+2)*(x+3)*(x+4));
                    3 2
                    x + 9x + 26x + 24
> expand(sin(2*x));
                    2 sin(x) cos(x)
> expand(sin(x+y));
                    sin(x) cos(y) + cos(x) sin(y)
> expand((x+1)*(y+1));
                    (x + 1) у + x + 1
> expand((x+1)*(y+z));
                    xy + xz + y + z
> expand((x+1)*(y+z), x+1);
                    (x + 1) у + (x + 1) z
> frontend(expand,[(a+b)^3]);
                    3 2 2 3
                    a + 3 a b + 3 a b + b

Для разложения целых или рациональных чисел на множители в виде простых чисел служит функция ifactor(n) или ifactor(n, method), где n — число, method — параметр, определяющий метод разложения. Другая библиотечная функция ifactors(n) возвращает результат разложения в форме вложенных списков:

Для алгебраических выражений функция факторизации записывается в вычисляемой и инертной формах: factor(a), Factor(a), factor(a, К) и Factor(а, К). Здесь а — полином с несколькими переменными, К — необязательное алгебраическое расширение. Для получения результата от инертной формы функции факторизации надо использовать функцию evala или evalgf.

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

> factor(a^2-2*a*b+b^2);
                    2
                    (а - b)
> expand((x-1)*(x-2)*(x-3));
                    3 2
                    x - 6 x + 11 x - 6
> factor(");
                    (x - 1) (x - 2) (x - 3)
> factor(x^5-2,2^(1/5));
                    1/5 4 1/5 3 2/5 2 3/5 4/5
                    (x - 2) (x + 2x + 2 x + 2 x + 2)
> factor(x^3+y^3);
                    2 2
                    (x + y) (x - x у + у)
> factor(x^3+y^3,(-3)^(1/2));
                    1/2 1/2
                    1/4 (2 x - у - I у 3) (2 x - у + I у 3) (x + у)
> factor(x^3+3,complex);
                    (x + 1,442249570) (x - .7211247852 + 1.249024766 I)
                    (x - .7211247852 - 1.249024766 I)

Еще одна функция общего назначения — collect — служит для комплектования выражения expr по степеням указанного фрагмента х (или множества, или листа). Она задается в виде collect (а, х) или collect(а, x, form, func). Во второй форме этой функции задаются необязательные параметры form(форма) и func(функция или процедура). Параметр form может иметь два значения: recursive (рекурсивная форма) и distributed (дистрибутивная форма). Параметр func позволяет задать имя функции, по которой будет идти комплектование expr. Примеры применения функции collect представлены ниже:

> f := а*ехр(х)-ехр(х)*х-х;
                    f := а ехр(х) - ехр(х) х - х
> collect(f,exp(x));
                    (а - х) ехр(х) - х
> p := х*у+а*х*у+у*х^2-а*у*х^2+х+а*х:
> collect( р, [у, х], recursive );
                    2
                    ((1 - а) х + (1 + а) х) у + (1 + а) х

Maple V R5 имеет обширные средства для работы с полиномами. Так, с полиномами можно выполнять обычные операции:

> р1:=a1*x^3+b1*x^2+c1*x+d1: р2:=а2*х^2+b2*х+с2:
> р1+р2;
                    3 2 2
                    а1 х + b1 х + с1 х + d1 + а2 х + b2 х + с2
> р1*р2;
                    3 2 2
                    (а1 х + b1 х + c1 x + d1) (а2 х + b2 х + с2)
> collect(",x);
                    5 4 3
           а1 а2 х + (b1 а2 + а1 b2) х + (с1 а2 + b1 b2 + a1 с2) х
                    2
           + (d1 а2 + с1 b2 + b1 с2) х + (d1 b2 + с1 с2) х + d1 c2
> p1/p2;
                    3 2
                    а1 х + b1 х + с1 х + d1
                  -----------------------------
                    2
                    а2 х + b2 х + с2

Для выделения коэффициентов полинома служит функция coef f, различные формы применения которой поясняют следующие примеры:

> р := а4 х + а3 х + а2 х + а1 х + а0
> coeff(p, х);
                    а1
> coeff(p,x^3);
                    а3
> coeff(p,x,4);
                    а4
> coeffs(p,x);
                    а0, а1, а4, а3, а2
> q:=x^2+2*y^2+3*x+4*y+5;
                    2 2
                    q := x + 2y + 3x + 4y + 5
> coeffs(q);
                    5, 3, 4, 1, 2
> coeffs(q,x,y);
                    2
                    5 + 2 у + 4 у, 3, 1
> collect(p,x);
                    4 3 2
                    а4 х + а3 х + а2 х + а1 х + а0

Полином может быть неполным, то есть не содержать членов со степенью ниже некоторой. Функция lcoeff возвращает старший коэффициент полинома нескольких переменных, a tcoeff — младший коэффициент полинома нескольких переменных:

> q:=1/x^2+2/x+3+4*x+5*x^2;
                    1 2
               q:= ---- + 2/х + 3 + 4 х + 5 х
                    2
                    х
> lcoeff(q,x);
                    5
> lcoeff(q,x,'t');
                    5
> t;
                    2
                    x
> coeffs(q,x,'t');
                    3, 4, 5, 2, 1,
> t;
                    2      1
           1, x, x, 1/x, ---------
                          2
                          x

Функция degree возвращает высшую степень полинома, a ldegree — низшую степень:

> р:=а4*х^4+аЗ*х~3+а2*х^2;
                    4 3 2
                    р := а4 х + аЗ х + а2 х
> degree(p,x);
                    4
> ldegree(p,x);
                    2

Для контроля наличия в полиноме несокращаемых множителей может использоваться функция irreduc(p) и ее вариант в инертной форме Irreduc(p, К), где К — выражение с функцией RootOf. Ниже приведены примеры применения этих тестовых функций:

Для разложения полинома р по степеням служат инертные функции AFactor(p) и AFactors(p):

> evala(AFactor(2*x^2+4*x-6));
                    2 (х + 3) (х - 1)
> evala(AFactor(x^2+2*y^2));
                    2 2
                    (х - RootOf(_Z + 2) у) (х + RootOf(_Z + 2) у)

Для вычисления действительных и комплексных корней полиномов служит уже известная нам функция solve(p, х), возвращающая список корней полинома р одной переменной. Кроме того, имеются следующие функции для вычисления корней многовариантных полиномов: roots(p), roots(p, К), roots(p, x) и roots(p, x, К). Корни возвращаются в виде [[r1,m1], ..., [rn,mn]], где ri — корень полинома, a mi — порядковый номер. Примеры:

> р:=х^4+9*х^3+31*х^2+59*х+60:
> solve(p,x);
                    -4, -3, -1 + 2 I, -1 -2 I
> roots(x^2-4,x);
                    [[-2, 1], [2, 1]]
> expand((x-1)*(x-2)*(x-3)*(x-4));
                    4 3 2
                    х - 10 х + 35 х - 50 х + 24
> roots(",x);
                    [[3, 1], [4, 1], [1, 1], [2, 1]]

С полиномами могут выполняться различные операции. Например, функция psqrt(p) возвращает квадрат полинома, a proot(p,n) — n-ю степень полинома. Функция real root (р) возвращает интервал, в котором находятся действительные корни полинома, a randpoly(vars,eqns) — случайный полином по переменным vars (список) и максимальной степенью eqns (например, degree=10). Функция discrim(p,var) вычисляет дискриминант полинома по переменной var, a Primitive(a) mod р обеспечивает проверку полинома на примитивность (возвращает true, если полином примитивен). В целом надо отметить, что аппарат действий с полиномами в Maple V R5 хорошо развит и позволяет выполнять с ними практически любые математические операции.