• Интерфейс пользователя
  • Строка меню и окно редактирования документов
  • Новинки системы Mathematica 4
  • Файловая система и пакеты расширений
  • Редактирование документа
• Ячейки
• Графика
• Звук
• Ввод элементов документа
• Ядро системы
• Справочная система
• Средства обычных вычислений
  • Вычисления с целыми и вещественными числами
  • Символьные данные, строки и выражения
  • Списки, массивы и объекты
  • Функции, ключи, атрибуты и директивы
  • Константы, размерные величины и переменные
  • Подстановки и функции пользователя
  • Арифметические операторы и функции
  • Функции генерации случайных чисел
  • Функции выявления погрешностей и анализа структуры чисел
  • Логические операторы и функции
  • Элементарные и специальные функции
• Расширенные возможности для работы с объектами
  • Оперативная справка
  • Средства диагностики и сообщения об ошибках
• Операции математического анализа
  • Суммы и произведения
  • Вычисление производных и интегралов
  • Вычисление пределов функций
  • Решение уравнений в символьном виде
  • Численное решение уравнений
• Решение дифференциальных уравнений
  • Решение в символьном виде
  • Решение в численном виде
• Разложение функций в степенной ряд
• Дискретное преобразование Фурье
• Интерполяция данных и аппроксимация функций
  • Полиномиальная интерполяция и аппроксимация
  • Рациональная Паде-аппроксимация
  • Регрессия и визуализация ее результатов
• Функции минимизации и максимизации
  • Поиск максимального и минимального чисел в списке
  • Поиск локального минимума аналитической функции
  • Поиск глобального максимума и минимума аналитической функции
• Массивы
  • Задание массивов
  • Функции для операций линейной алгебры
  • Решение систем линейных уравнений
• Символьные вычисления
  • Выражения
  • Функции
  • Упрощение выражений
  • Раскрытие и расширение выражений
  • Функция Collect
  • Функции преобразования тригонометрических выражений
  • Разложение полиномов
  • Функции для работы с полиномами
• Средства программирования
  • Виды программирования в системе Mathematica 4
  • Задание чистых и анонимных функций
  • Циклы и рекурсия при функциональном программировании
  • Основы процедурного программирования
• Управляющие структуры
  • Цикл Do
  • Цикл For
  • Цикл While
  • Директивы прерывания и продолжения циклов
  • Условные выражения
  • Функции-переключатели
  • Безусловные переходы
• Механизм контекстов
• Типовая структура пакетов расширения

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

При запуске системы Mathematica 4 можно наблюдать появление элементов интерфейса системы прямо на рабочем столе Windows 95/98/NT (рис. 9.1). Интерфейс определяется одной из двух основных частей системы — интерфейсным процессором Front-end (вторая основная часть представляет собой ядро системы Kernel). После загрузки интерфейсного процессора появляется строка меню системы, палитра ввода и пустое окно редактирования документов (даже без курсора ввода). В нем можно начинать вычисления, что и иллюстрирует рис. 9.1. В последней строке документа показан шаблон ввода определенного интеграла, введенного с помощью палитры ввода.

Рис. 9.1. Вид запущенной системы Mathematica на рабочем столе Windows 98

Для выполнения простых вычислений достаточно набрать в строке ввода необходимое математическое выражение и нажать клавиши Shift+Enter (клавиша Enter задает перевод строк). Результат появится в строке вывода. В Mathematica необычна форма задания функций — они начинаются с большой буквы, а аргументы Функций задаются в квадратных скобках, например Sin[1], а не sin(1). Круглые скобки используются для задания приоритета вычислений в сложных выражениях. Десятичная точка делает число вещественным, а особая функция N[expr] или N[expr,n] вычисляет выражение ехрr в виде вещественного десятичного числа с плавающей точкой и n знаками после этой точки.

Строка меню Mathematica 4 имеет следующие характерные позиции: Cell — работа с ячейками (их объединение и разъединение, установка статуса, открытие и закрытие); Format — установка форматов документов (шрифты, стили, размеры, фон, цвета и т. д.); Input — задание элементов ввода (графиков, матриц, гиперссылок и др.); Kernel — управление ядром системы и свойствами ячеек; Find — поиск заданных данных об объектах.

Палитры спецзнаков (рис. 9.2) выводятся с помощью команд подменю Palettes меню File.

Рис. 9.2. Палитры спецзнаков системы Mathematica 4

Для форматирования документа используются команды меню Format. Для ввода математического выражения по шаблону и для представления его в естественной математической форме используется стандартный формат ячеек ввода. Преобразование форматов ячеек выполняется командами меню Cell. На рис. 9.3 показан созданный простой документ.

Каждая надпись, математическое выражение или график занимают отдельную ячейку (cell). Ячейка может занимать одну или несколько строк и всегда выделена справа квадратной скобкой. Между ячейками можно вставлять новые ячейки ввода.

В новых версиях Mathematica 3/4 команды для установки стиля интерфейса находятся в меню Format: Show Ruller — отображение линейки; Show ToolBar — отображение панели инструментов; Show Page Break — отображение линии разрыва страницы; Magnitification — задание (в процентах) масштаба отображения элементов документа.

В системе Mathematica 4 кардинально повышена скорость численных расчетов (рис. 9.4).

Эта возможность достигнута за счет существенного ускорения построения сложных трехмерных фигур и реализуется с помощью команды << RealTime3D'. Другая команда << Default3D' возвращает систему к стандартным возможностям построения трехмерной графики.

Документы системы представлены файлами текстового формата и имеют расширение .nb. Сохранение и считывание файлов осуществляется обычным способом — помощью команд меню File. Система имеет ряд пакетов расширения (AddOns) системы, которые хранятся в папке ADDONS:

Кроме обычных команд (см. главу 5) в меню File имеется ряд специфических:

Помимо обычных средств редактирования (команд меню Edit) документов в Mathematica предусмотрены обширные возможности по изменению стиля документов и их частей — команды меню Format.

Стилем ячеек называют именованную совокупность параметров форматирования ячеек. Команды для назначения стиля собраны в подменю Style меню Format. Это команды ScreenStyleEnvironment — изменение текущего формата отображения ячеек документа на экране и PrintStyleEnvironment — изменение текущего формата ячеек документа при печати. Доступны следующие параметры: Working — рабочий стиль (типичный); Presetnation — презентация (увеличенные размеры символов); Condesed — сжатый (уменьшенный размер символов); Printout — принтерный (оптимальный при печати). Команда ShowExpression служит для управления отображением выражений в стандартном и развернутом видах (со всеми директивами и параметрами). Команда RemoveOptions удаляет все введенные пользователем настройки и восстанавливает исходное состояние системы.

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

Команды подменю Save Selection As (рис. 9.5) служат для записи выделенных ячеек в специальных форматах.

Рис. 9.5. Подменю Save Selection As

Команда Insert Object открывает стандартное диалоговое окно вставки объектов. В окне есть перечень приложений, экспортирующих в Mathematica порожденные ими объекты.

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

В меню Cell имеются команды для работы с ячейками: преобразования и изменения формата, группировки, объединения и разделения ячеек. Команды подменю Cell Properties служат для установки свойств — статуса ячеек. Это команды Cell Open, Cell Editable, Cell Edit Dublicate, Cell Evaluatable, Cell Active и Initialization Cell, которые описаны ниже.

Ячейка ввода и соответствующая ей ячейка вывода обрамляются не только своими удлиненными квадратными скобками справа, но и общей скобкой. Активизируя эту скобку двойным щелчком, можно скрывать или выводить на экран выходную ячейку. Скрывать последнюю полезно, если содержащийся в ней результат слишком громоздок. Можно форматировать не только входные, но и выходные ячейки, например, вручную задавая более приемлемый вид результата. Однако для этого надо выходную ячейку сделать редактируемой (команда CellEditable). Редактируемая ячейка имеет символ ´ у своей обрамляющей скобки.

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

Ячейки также могут быть активными и неактивными. Изменение активности достигается командой Cell Active. Активная ячейка помечается в скобке знаком А и обычно управляется кнопкой. Наконец, ячейки могут быть инициализированными или нет (команда Initialization Cell). Инициализированная ячейка помечается в скобке знаком | и автоматически исполняется при загрузке документа, содержащего такую ячейку (или ряд ячеек).

Команда Group Cells используется для объединения ряда ячеек в одну группу. Группу можно раскрывать и сжимать, активизируя ее общую квадратную скобку. Команда Ungroup Cells разъединяет объединенные в группу ячейки. Для деления ячейки на части используется команда Divide Cell, а для объединения двух ячеек — команда Merge Cells. Команда Open All Subgroups открывает все подгруппы, а команда Close All Subgroups закрывает все выделенные группы и подгруппы ячеек. Это позволяет создавать электронные документы.

Система Mathematica обладает превосходными графическими возможностями и имеет для этого множество функций. Например, графическая функция Plot[{f1[x], f2[x],...}, {х, xmin, хmах}] строит графики произвольных математических функций f1[х], f2[х], ... одной переменной х при ее изменении от минимального значения xmin до максимального хmах (рис. 9.6). Другая графическая функция Plot3D[f[x,y], {{х,xmin,xmax}, {y,ymin,ymax}}] строит график трехмерной поверхности для математической функции f [х,у] двух переменных, изменяющихся в указанных пределах. Он также показан на рис. 9.6 вместе с его контекстным меню.

В меню Cell имеется ряд команд, относящихся только к ячейкам вывода с графическими и звуковыми объектами (в версиях Mathematica 3.0 и ниже они находились в меню Graph): Animate Selected Graphics — анимация выделенной ячейки с графиком; Play Sound — воспроизведение синтезированного звука; Rerender Graphics — перерисовка графиков; Rerender And Save Graphics — перерисовка графиков и их запись; Make Standard Size — установка стандартного размера ячейки; Allign Selected Graphics — объединение выделенных графиков; Cell Size Statistics — вывод статистики о размерах ячеек.

Команда Get Graphics Coordinates выводит окно координат двухмерных графиков. Для получения координат двухмерных графиков прежде всего их надо выделить, а затем, удерживая клавишу Ctrl, поместить указатель мыши на нужной точке графика. При этом в левой нижней части окна появится список с координатами точки (координаты x и y в фигурных скобках). Затем следует воспользоваться командой Сору для переноса координат точек в буфер обмена для последующего использования.

Многие параметры документов задаются по умолчанию. В Mathematica 4 имеется специальный инспектор параметров (рис. 9.7), который можно запустить командой Option Inspector меню Format или контекстного меню (см. рис. 9.6).

Команда 3D View Point Selector служит для вывода окна настройки трехмерных графиков (рис. 9.8). Это окно можно открыть при наличии в документе трехмерного графика и установке в строку ввода с графической функцией курсора ввода.

В этом окне имеется изображение куба в пространстве, который можно вращать с помощью мыши или перемещением бегунков на полосах прокрутки, задающих параметры просмотра и перспективы объекта (увы, сам объект при этом не виден). Щелчок на кнопке Paste создает строку ViewPoint[{x,у,z}], которая помещается на место курсора ввода в окне редактирования документа. В данном случае курсор ввода надо расположить в строке функции Plot3D после запятой следом за списком параметров. Если теперь исполнить модифицированную функцию, то рисунок будет перестроен (рис. 9.9).

Команда Record Sound выводит окно Фонографа, входящего в состав операционной системы Windows 95/98 (рис. 9.10) и позволяющего записывать и воспроизводить звуки.

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

В этом разделе мы рассмотрим команды меню Input. В документ могут быть вставлены различные объекты, хранящиеся в файлах различных форматов, например текстовых или графических. Команда Get File Path открывает окно загрузки таких файлов.

Создание таблиц и матриц в системе Mathematica легко выполняется с помощью соответствующих функций. Однако команда Create Table/Matrix/Palette обеспечивает такую возможность и с помощью меню. Она выводит окно задания таблиц матриц и палитр, показанное на рис. 9.11 справа.

Рис. 9.11. Работа с окном Create Table/Matrix/Palette

При подготовке сложных документов с диалоговым режимом иногда полезно создание кнопок. Оно реализуется с помощью команд подменю Create Button, которые представляют собой имена типов кнопок. Например, кнопка типа Evaluate Cell служит для создания исполняющей вычисления ячейки. Она выглядит как прямоугольник. Редактирование кнопок осуществляется по команде EditButton.

Гиперссылка является объектом в виде подчеркнутой текстовой надписи, связанной с некоторым другим объектом, представленным файлом, например, какого-либо документа или рисунка. При активизации гиперссылки мышью связанный с ней объект загружается. Для создания гиперссылки выделяется какое-либо слово (или фраза), а затем выбирается команда Create Hyperlink. Открывается окно, показанное на рис. 9.12 в правой части экрана.

Следующий этап заключается в установке связи гиперссылки с нужным файлом. Его полное имя можно прямо указать в верхнем поле над кнопкой Browse. Этой кнопкой можно воспользоваться для поиска файла. После этого выделенное слово (фраза) превратится в гипертекстовую ссылку.

Для вставки содержимого предшествующих ячеек ввода и вывода служат команды Copy Input from Above и Copy Output from Above. Поясним это примерами. Введем в ячейку ввода выражение 1+2. Нажав клавиши Shift+Enter, получим строку вывода — 3. Теперь, выбрав команду Copy Input from Above, получим новую строку ввода — 1+2. Ее исполнение даст 3. Последующий выбор команды Copy Output from Above тоже даст 3. Еще одна команда Start New Cell Bellow служит для вставки новых пустых ячеек ввода между уже имеющимися. Ячейка вставляется ниже курсора ввода, указывающего место вставки.

Запомнить около тысячи функций, входящих в ядро систем Mathematica, довольно сложно, так же как и правила их записи. Для облегчения ввода служат две заключительные команды меню Input. Первая из них доступна, если курсор находится на каком-либо ключевом слове в строке ввода. Тогда выбор команды Complete Selection выводит список имен всех функций, которые содержат данное слово. Рис. 9.13 поясняет это на примере ввода слова Plot.

Рис. 9.13. Пример исполнения команды Complete Selection

Соответственно, команда Make Template в указанной курсором функции выдаст список ее параметров. Например, если введено слово Plot и курсор ввода расположен следом за ним, команда Make Template приведет к следующему изменению строки ввода: Plot [f, x, xmin, xmax]. После этого становится ясно, как записывается эта функция и какие параметры требуется ввести.

Команды меню Cernel служат для управления действиями ядра системы, проводимыми над ячейками загруженного документа. Здесь есть также команды ввода субсекции Enter Subsection и удаления субсекции Exit Subsection. Часто используются команды Interrupt — прерывание вычислений и Abort — полное прекращение вычислений.

В Mathematica предусмотрена команда Show In/Out Number, управляющая отображением или скрытием сообщений с номерами строк In[n] и Out[n]. Для отображения или скрытия всех ячеек вывода служит команда Delete All Output.

В меню Find представлены команды поиска и замены фрагментов текстов и выражений.

Особым признаком ячеек ввода могут быть их комментарии (tags) — короткие сообщения, характеризующие суть выполняемых в ячейках действий и размещаемые над строкой ввода. Признаком наличия у данного документа комментариев является их список, который появляется в подменю Cell Tags меню Find. Команда Add/Remove Cell Tags позволяет добавить комментарий в строку ввода, если его нет, или удалить комментарий из строки, если он есть. Эта команда вызывает появление окна редактирования комментариев. Работа с этим окном вполне очевидна — кнопка Add добавляет комментарий, а кнопка Remove удаляет. Команда Cell Tag from In/Out Name позволяет добавить в список комментариев заголовок выделенной строки ввода или вывода.

Последняя команда меню Find — Make Index — помещает в буфер обмена все комментарии текущего документа. Она выводит окно, в котором можно указать признаки комментариев. Щелчок на кнопке ОК помещает список этикеток в буфер обмена, откуда его можно извлечь с помощью команды Paste.

Mathematica 4 имеет прекрасно исполненную справочную базу данных (рис. 9.14). Команды доступа к ней, как обычно, сосредоточены в меню Help.

Рис. 9.14. Окно справочной системы Mathematica

В окне справочной системы можно установить следующие разделы справок: Built-in Functions — встроенные функции; Add-ons — пакеты расширений; The Mathematica Book — математический справочник; Getting Started/Demos — начало работы и демонстрации; Other Information — другая информация; Master Index — справка по индексу (алфавитный каталог).

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

В меню Help имеется еще ряд команд: Registration — вывод формы регистрации; Find in Help — поиск нужных разделов в справочной системе; Why the Beep? — зарезервирована под выдачу информации о звуковых возможностях; About Mathematica — вывод окна с краткими данными о системе и фирме Wolfram; Rebuild Help Index — создание индексного указателя. Действие этих команд вполне очевидно.

При работе с целочисленными данными Mathematica 4 обеспечивает точные вычисления:

Знак % означает использование последнего результата вычислений. Для вычисления чисел с произвольным основанием используется конструкция Основание^^Число:

Функция BaseForm[expr, n] возвращает выражение ехрr в форме числа с основанием n (до 32), которое указывается как подстрочный индекс:

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

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

Функции IntegerPart[x] и FractionalPart[x] обеспечивают возврат целой и дробной частей вещественного числа х, а функция RealDigits[x] возвращает список реальных цифр результата и число цифр целой части х. Есть множество и других функций для работы с числами.

Символьные строки задаются цепочкой символов в кавычках, например "sssss". В них могут использоваться следующие управляющие символы для строчных объектов: \n — новая строка, \t — табуляция. Это иллюстрируется следующими примерами:

Выражения в системе Mathematica обычно ассоциируются с математическими формулами, например (слева запись на языке Mathematica, справа — обычная математическая запись):

Наиболее общим типом сложных данных в системе являются списки (lists). Они, как и векторы, и матрицы, задаются следующим образом:

В общем случае система Mathematica оперирует с объектами, имена (идентификаторы) которых строятся по следующим правилам: sssss — имя объекта, заданнoro пользователем; Sssss — имя объекта, входящего в ядро системы; $Sssss — имя системного объекта. Различные объекты системы будут более подробно описаны в дальнейшем по мере знакомства с системой. Полный список объектов, заданных в ядре системы, легко получить, используя команду ?*. Можно также получить список всех определений на заданную букву, используя команду ?S*, где S — любая буква латинского алфавита. Аналогичные возможности представляет функция Name["S"], например, Names["A*"] выводит список всех ключевых слов начинающихся с символа А. Наконец, командой ?Name можно вывести справку по любому определению с именем Name, например, ?Sin выводит сообщение Sin[z] gives the sine of z. С помощью команды ?Name можно проверить, является ли имя объекта Name уникальным или оно уже использовано в системе.

В числе входных параметров могут быть специальные объекты — ключи. Они задаются в виде Имя_ключа->3начение_ключа. Значением ключа обычно является то или иное слово. Например, в функции построения графиков Plot[sin[x], {x,0,20}, Axes->None] параметр Axes->None указывает на то, что отменяется вывод координатных осей (Axes). Функция Options[name] выводит для функции с идентификатором name список всех возможных для нее ключей. Некоторые функции, например Sin, могут вообще не иметь ключей, другие, например Solve, могут иметь целый “букет” ключей.

Каждый объект может характеризоваться некоторой совокупностью своих свойств и признаков, называемых атрибутами. Функция Attributes[name] возвращает список всех атрибутов функции с именем name, например:

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

В Mathematica 4 используются следующие именованные константы: Complex Infinity — комплексная бесконечность; Degree — число радиан в одном градусе, которое имеет числовое значение Pi/180; E — основание натурального логарифма c приближенным числовым значением 2,71828...; EulerGamma — постоянная Эйлера с числовым значением 0,577216...; GoldenRatio — константа со значением (1+Sqrt[5])/2, определяющая деление отрезка по правилу золотого сечения; I — представляет мнимую единицу Sqrt[-1]; Infinity — “положительная” бесконечность (со знаком минус — “отрицательная” бесконечность); Catalan — константа Каталана 0,915966...; Pi — число p . Имеющие значение константы хранят их в виде вещественных чисел:

Mathematica позволяет оперировать с размерными величинами, которые широко используются для физических и химических расчетов. Например, 1 Meter или 0.5 Second.

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

Различие в присваивании переменным значений с помощью знаков = и := иллюстрируют следующие примеры: а=12 возвращает 12, b:=15 возвращает в разных строках b и 15.

Возможно снятие с переменной определения с помощью символа =. (знак равенства с точкой). Указанным операторам присваивания соответствуют функции обычного присваивания Set[lhs,rhs] и задержанного присваивания SetDelayed[lns,rhs]. Есть и другие редко используемые функции присваивания UpSet[lns,rhs] и UpSetDelayed[lhs,rhs]. Отметим еще одну важную конструкцию:

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

Операции подстановки в Mathematica вводятся с помощью комбинированного символа /. (слеш с точкой): ехрr /. х -> value — в выражение ехрr вместо переменной х подставляется ее значение value; ехрr /. {х -> xvalue, у -> yvalue} — в выражение ехрr вместо переменных х и у подставляются их значения xvalue и yvalue. Примеры:

1+x^3/.x->1+z
1+(1+z)³
х^2+2*х+3/.х->2
11

В целом для операций подстановок (rule) используют следующие обозначения: lhs -> rhs — прямая подстановка lhs в rhs и lhs :> rhs — задержанная подстановка (ruledelayed), которая преобразует lhs в rhs, вычисляя rhs только в том случае, если используется правило подстановки:

р:=1+х^2+3*х^3
р/.х->1+у
1 + (1+у)²+3(1+у)³
f[1],f[2],f[3]/.f[n_]->n^2
{1, 4, 9}
f[n_]:=n^2
f[4]+f[y]+f[x+y]
16+у²+(х+у)²

В обозначениях вида х_ знак _ применяется для создания так называемых образцов, задающих локальные переменные в теле функции (в нашем примере это х^3). При этом в самом теле функции переменные обозначаются как обычно, без знака образца. Mathematica имеет ряд и других образцов (см. справочную систему). Mathematica позволяет записать введенные пользователем функции с их определениями на магнитный диск с помощью инструкции: Save["filename", f1, f2, ...]. После этого функция пользователя становится внешней функцией. При этом для ввода таких функций в текущий документ достаточно вызвать файл с именем filename: <<filename.

Рекомендуется создавать файлы с типовым расширением .m. Такие файлы входят в пакеты расширений системы. Имя файла нужно задавать по общепринятым для MSDOS правилам, то есть при необходимости указывать идентификатор логического диска и путь к файлу, например: <<D:\MAT\myfunc.m.

Функции пользователя можно задавать и выводить на печать как на языке системы, так и на некоторых общепринятых языках программирования, например Fortran, С или ТеХ. Для этого существует ряд функций преобразования, например CForm[expr], FortranForm[expr] и TeXForm[expr]. Для подсоединения созданных на этих языках программ, содержащих формулы и данные, в вывод системы Mathematica используются функции: Splice["file.mx"] — включает вывод системы во внешний файл и Splice["infile","outfile"] — включает вывод системы в файл infile и отправляет результат в файл outfile. Таким образом, система Mathematica может общаться с другими программами, написанными на тех или иных языках программирования.

Mathematica 4 помимо общепринятых арифметических операторов (+, -, *, / и ^) имеет оператор ехрr //N, который дает приближенное (с установленной точностью и формой) значение выражения ехрr. Полезно отметить, что знак пробела является арифметическим оператором умножения, если по обе стороны от него стоят операнды. Знак % возвращает результат последней предшествующей операции, а %% возвращает результат операции, выполняемой перед последней предшествующей операцией, и т. д.

Если х имеет вещественное значение, функция MantissaExponent[x] возвращает список, содержащий мантиссу и порядок приближенного вещественного числа х. Следующие две функции, Rationalize[x] и Rationalize[x,dx], дают приближение для числа х в виде рациональных чисел (вторая из этих функций задает приближение с заданной точностью):

Rationalize[N[Pi],10^-3]

Rationalize[N[Pi],10^-12]

Спецификой Mathematica являются арифметические операторы с укороченной

В дальнейшем при такой форме представления примеров мы будем опускать указания на ячейки ввода (слева) и вывода (справа). Для выполнения арифметических действий в Mathematica 4 определены следующие арифметические функции:

К целочисленным функциям можно отнести функции вычисления факториалов: Factorial[n] или n! — возвращает значение факториала числа n; Factorial2[n] или n!! — возвращает значение двойного факториала числа n. Примеры на вычисление факториалов:

Для реализации статистических методов моделирования используются случайные числа. Система имеет генератор псевдослучайных чисел, доступ к которому обеспечивают функции Random[ ] — возвращает равномерно распределенное псевдослучайное число типа Real в интервале от 0 до 1 и Random[type, range] — возвращает псевдослучайное число указанного типа type, лежащее в указанном интервале range. К возможным типам относятся: Integer, Real и Complex. По умолчанию принят интервал от 0 до 1. Можно задать интервал явно {min, max}; спецификация интервала max эквивалентна {0, max}. Функция SeedRandom[n] устанавливает в начальное состояние генератор случайных чисел, используя целое n как начальное, а функция SeedRandom[ ] устанавливает в качестве начального числа время дня.

Aссurасу[123.456]
14
EvenQ[2*3+2]
True
EvenQ[2*3+3]
False
IntegerDigits[12345]
{1,2,3,4,5}
IntegerDigits[12345,16]
{3,0,3,15}
IntegerDigits[12352,16]
{3,0,4,0}
IntegerDigits[12352,2]
{1,1,0,0,0,0,0,0,1,0,0,0,0,0,0}
Precision[123.452]
16

Функциями Accuracy и Precision возвращаются значения, установленные в последний раз или по умолчанию при первой загрузке системы.

Для осуществления логических операций используются следующие логические операторы: == — равенство (например, а == b); != — неравенство; > — больше (например, b > а); >= — больше или равно; < — меньше; <= — меньше или равно. Возможны следующие формы их применения: а == b == с; а != b != с и х < у < z и т. д. Результатом исполнения этих выражений является выдача логических значений True или False. Основные логические функции над логическими данными р, q и пр. задаются следующим образом: Not[p] или !р — логическое отрицание; And [р,q,...] или р && q && ... — логическое умножение (логическое И); Or[p,q,...] или р || q || ... — логическое сложение (логическое ИЛИ). Приведем примеры применения логических операторов и функций:

К основным логическим средствам относятся и следующие функции: Equal [lhs,rhs]; Greater[x,y]; GreaterEqual[x,у]; Negative[x]; NonNegative[x]; Positive[x]; Xor[e1, e2, ...]. Примеры:

Mathematica поддерживает полный набор элементарных функций: Abs[z] — возвращает абсолютное значение для действительного числа и модуль для комплексного z; ArcCos[z] — возвращает арккосинус комплексного числа z, ArcCosh[z] — возвращает значение гиперболического арккосинуса комплексного аргумента z и т. д. В связи с общеизвестностью элементарных функций ограничимся приведением лишь нескольких примеров их использования:

Mathematica поддерживает также следующие функции для работы с комплексными числами: Abs[z] — возвращает модуль комплексного числа; Arg[z] — возвращает аргумент комплексного числа z; Conjugate[z] — возвращает комплексно сопряженное с z число; DirectedInfinity[ ] — представляет бесконечную числовую величину с неопределенным направлением на комплексной плоскости; DirectedInfinity[z] — представляет бесконечную числовую величину, являющуюся положительной вещественной кратной комплексному числу z; Im[z] — возвращает мнимую часть комплексного числа z; Re[z] — возвращает вещественную часть числа z. Ниже приведены примеры операций с комплексными числами:

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

Оперативную справку в ходе работы с системой о назначении какой-либо функции можно получить, используя следующие инструкции: ?Name или Names ["Name"] — справка по заданному слову Name; ??Name — расширенная справка по заданному слову Name; ?Abc* — перечень всех слов, начинающихся с Abc; Options[name] — получение информации о параметрах объекта Name. Примеры на эти операции:

Нетрудно заметить, что есть два уровня оперативной справки. Так, команда ?Sin дает лишь сообщение о назначении функции, a ??Sin предоставляет дополнительную информацию о признаках функции. Все параметры функции Sin позволяет получить команда Names["Sin*"].

При ошибке в вычислениях Mathematica выдает сообщение об ошибке в следующем виде: Тип :: Метка%Диагностика:Сообщение. Эти сообщения появляются в отдельных неактивных ячейках. Тип указывает на тип ошибки, например, General — ошибка общего вида, Syntax — синтаксическая ошибка, Arg — ошибка задания аргумента и т. д. Метка указывает место ошибки в списке ошибок данного типа, а Диагностика указывает (увы, не всегда) на ошибочное выражение. Сообщение обычно раскрывает суть ошибки. Для отключения сообщений об ошибках служит инструкция Off [Function::tag]. Для включения сообщения об ошибках используется инструкция On[Function::tag].

Объекты Mathematica имеют средства защиты от модификации и отмены такой защиты. Для этого используются директивы Protect и Unprotect. Защита идентификаторов объектов от модификации является мощным средством контроля правильности вычислений, но в практике обычных вычислений почти не применяется.

Для вычисления сумм предусмотрена функция Sum, используемая в ряде форм:

Sum[i^2,{i,1,2,0.25}]
11.875

770
Sum[xiyj,{i,1,4},{j,1,4}]
ху+х²у+х³у+х⁴у+х²у²+х³у²+х⁴у²+х³у³+х⁴у³+х⁴у⁴

Для вычисления сумм в численном виде используются те же функции с добавлением в начало имени буквы N, например NSum[f, {i, imin, imax}]:

Операции вычисления произведений представлены функциями Product в той же нотации, что и Sum:

Для вычисления производных используются следующие функции: D[f,x] — возвращает частную производную функции f по переменной x; D[f, {x, n} ] — возвращает частную производную n-го порядка по x; D[f, x1, х2, ...] — возвращает смешанную производную; Dt[f, х] — возвращает обобщенную производную функции f по переменной x; Dt[f] — возвращает полный дифференциал f.

Для функции D существует параметр NonConstants, который возвращает список объектов, находящихся в неявной зависимости от переменных дифференцирования. По умолчанию список пуст. Аналогично, для функции Dt имеется параметр Constant (по умолчанию возвращает пустой список). На практике применение данных параметров встречается редко. Существует еще одна функция Derivative[n1, n2, ...][f] — основная (общая) форма представления функции, полученной в результате дифференцирования f n1 раз по первому аргументу, n2 раз по второму аргументу и т. д. К примеру, Derivative[2][x*y] возвращает (х у)'', a Derivative[2, 3][х*у] — соответственно, (х у)^(2,3). Примеры:

Использование функции Dt демонстрируют примеры, приведенные ниже:

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

Обычно функция Integrate применяется прямо, но она имеет три характерных параметра, список которых позволяет получить команда Options[Integrate].

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

Integrate[{Sin[x],Tan[x],Cosh[x],ArcSin[x]},x]




EulterGamma-CosIntegral[x²y]+Log[x²y]

Для вычисления численных значений определенных интегралов используется функция NIntegrate[f, {x, xmin, xmax}]. Она возвращает численное приближение интеграла от функции f по переменной х на интервале от xmin до xmax и имеет ряд параметров. С ними можно ознакомиться по справочной системе. Полный перечень параметров выводится командой Options[NIntegrate]. Приведем примеры на использование функции Nintegrate:

NIntegrate[Sqrt[2*x+1],{x,0,1}]
1.39872
NIntegrate[1/(x*y),{x,4,4.4},{y,2,2.6}]
0.025006
NIntegrate[x*y,{x,0,1},{у,х,х^2},{z,x*y,x^2*y^3}]
0.010582

Функция NIntegrate с успехом может применяться и для вычисления кратных интегралов и интегралов с переменными пределами.

Для вычисления пределов выражения ехрr используется функция Limit[expr, opts], где параметр opts задает точку, для которой ищется предел, и направление подхода к пределу:

Для решения уравнений (как одиночных, так и систем) в численном и символьном видах Mathematica поддерживает функцию Solve[eqns, vars], обеспечивающую решение системы equns относительно переменных vars, и Solve[eqns, vars, elims], обеспечивающую решение с исключением переменных elims. Входные параметры этой функции могут быть представлены списками или записанными через объединительный знак && выражениями. В eqns в качестве знака равенства используется знак ==. Примеры на применение функции Solve представлены ниже:

Solve[2*x^2 - 5*х - 10 == 0, х]

Solve[{x^2+y^2+z==5,x*y+z==2,x+y+z==3},{x,y,z}]
{{z®0,x®1,y®2},{z®0,x®42,y®1},{z®3,x®1,y®1},{z®3,x®1,y®-1}}

N[Solve[x3-y^2==6&&x^2-y==3,x,y]]
{{у® 0.345604,х® 1.8291},{у® 2.86285,x® 2.42133},
{у® -1.10423-2.80661,х® -1.62522+0.863454I},
{у® -1.10423+2.80661,х® 1.62522-0.863454I}}

е=х==2+3 ах, у==5+2х
{х==2+3ах,у==5+2х}
r=Solve[e,x,y]

e/.r

Этот пример показывает, что решение все же верно, хотя подстановка не дала сразу явный результат в виде {{True}, {True}}. Теперь рассмотрим простую и явно имеющую решение (например, при х=2 и у=3) систему уравнений х*у=6 и х^2+у=7:

eqns={x*y==6, х^2+у==7}
result=Solve[eqns,{х,у}]
{{у® -2,х® -3},{у® 3,х® 2},{у® 6,х® 1}}
eqns/.result
{{True,True}, {True,True}, {True,True}}

Оказывается, что Mathematica в этом случае дает сразу три пары решений, и все они верны, поскольку после подстановки получены все утверждения True. В следующем примере показано решение системы нелинейных уравнений с помощью функции Solve:

Solve[{x^2+y==a,y^2==a+b},{x,y}]

С функцией Solve можно использовать ряд параметров, выводимых командой Options[Solve].

Приведем пример на применение функции Solve с параметром InverseFunctions:

Solve[2*Sin[x/2]*Sec[2*x]^-1==0,x,InverseFunctions->True]

Степень влияния на решение параметра Method наглядно иллюстрирует следующий пример:

Solve[x^3-y^2==7&&x^2-y==3,х, у, Method->1 ]
{{-6х²-х³+х⁴® -16,у® -3+х²}}

Если теперь задать Method->3, то будет получен куда более сложный, но численный результат.

Для численного решения систем нелинейных уравнений используется функция NSolve[eqns, vars], которая пытается решать численно одно уравнение или систему уравнений относительно переменных vars, и NSolve[eqns, vars, elims], которая пытается решать численно уравнения относительно переменных vars, исключая переменные elims. Единственный параметр этих функций — WorkingPrecision — определяет число верных цифр результата (по умолчанию 16). Приведем примеры использования функции NSolve для численного решения уравнений:

NSolve[y*x^2==9,х*у^2==3,х,у]
{{х® -1.5-2.598081,у® -0.5-0.866025},
{х® -1.5+2.598081,у® -0.5+0.8660251},{х® 3.,у->1.}}
е=2*х^2 + 5*х - 15 == х^3
-15+5х+2х²==х³
r=Nsolve[e,x]
{{х® -2.4734},{х® 2.2367-1.03038I},{x® 2.2367+1.03038I}}
е/.r
{True, True, True}

Для вычисления корней уравнений, например многочленов, используется функция Roots[lhs==rhs, var]. Она дает дизъюнкцию уравнений, которая представляет корни уравнения. Следующие примеры иллюстрируют применение функции Roots:

Roots[x^2+2*x+15==0,x]

Roots[x^5+8*x^4+31*x^3+80*x^2+94*x+20==0,x]

Формат выдачи результатов у функции Roots отличается от такового для функции Solve. Поэтому проверку решения подстановкой надо выполнять следующим образом:

е=х^2 + 3х == 2
Зх+х²==2
N[Roots[e,x]]
x == -3.56155 || х == 0.56133
r={ToRules[%]}
{{х -> -3.56155}, {х -> 0.56133}}
е/. r
{True, True}

Для преобразования результата вычислений в список решений (подобный решениям с помощью функции Solve) использована функция ToRules. При затруднениях в решении уравнений с помощью функции Roots допускаются следующие параметры, выводимые командой Options[Roots]. Применение параметров нередко позволяет получать решения, которые не удаются с первого раза. На рис. 9.15 показан пример нахождения всех корней уравнения xsin•(x)+x/2-1=0. Полезно разобрать этот пример.

Рис. 9.15. График функции х•sin(x)+x/2-l и пример вычисления всех ее корней в интервале изменения х от 20

Специальный формат результатов не позволяет использовать неизвестные в явном виде. Однако от этого затруднения легко избавиться, если перед конструкцией блока решения задать выражение следующего вида: {х,у,z,...}/.. Ниже этот прием показан в действии:

FindRoot[{x^2==9_ly^2==16,x+y+z==10},{x,1.},{у.1.},{z,1.}]
{х->3.,у->4.,z->3.}
{x,y,z}
{x,y,z}

{а,b,с}=%
{3.,4.,3.}
а,b,с
{3.,4.,3.}
а
3.
b
4.
с
3.

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

В решении ДУ встречаются постоянные интегрирования. В общем случае они обозначаются как С[i]. Приведем примеры решения ДУ:

DSolve[Derivative[1][y][x] == 2*а*х^3, у[х], х]

Dsolve[y'[x]==Sin[Ex],y[x],x]
{{y[x]® C[1]+SinIntegral[E^x]}}
Dsolve[x2w"[z]+zw'[z]-(z2+1)w[z]==0,w[z],z]

Для численного решения систем ДУ используются следующие функции: NDSolve [eqns, у, {х, xmin, xmax}] — ищет численное решение ДУ eqns относительно функции y независимой переменной х в интервале от xmin до xmax; NDSolve[eqns, {y1, y2, ...}, {х, xmin, xmax}] — ищет численные решения относительно функций yi. Кроме того, имеется параметр MaxSteps к функции NDSolve, который определяет максимальное количество шагов. Пример решения системы ДУ с построением графика решения дан на рис. 9.16.

Показатели степеней (х-х0) представлены величинами nmin/den, (nmin+D/den,..., nmax/den. Обычно разложение сложнее дает некоторую остаточную погрешность — член 0[х]ⁱ:

Series[Tanh[x],{x,0,7}]

Series[Sin[x*y]₁{x,0,5},{y,0,5}]

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

Series[Sin[x],{x,0,7}]

Collect[%,x]

Normal[Series[Sin[x*y],{x,0,3},{у,0,3}]]

f[x_,y_]=xy-x^3y^3/6

f[0.1,0.2]
0.0199987

F[x_,y_]=Normal[Series[Sin[x*y],{х,0,3},{у,0,3}]]

F[0.1,0.2]
0.0199987

Быстрое прямое и обратное преобразования Фурье (БПФ) Mathematica 4 реализует функциями Fourier[list] и InverseFourier[list]. Преобразование выполняется для списка list комплексных чисел. Результаты прямого и обратного преобразований Фурье должны приводить к результату, совпадающему с исходными данными (в пределах малой погрешности):

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

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

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

InterpolationOrder — параметр к функции Interpolation, который определяет степень подходящего полинома. Применение основной функции Interpolation поясняет следующий пример:

Для решения задач регрессии в системе Mathematica 4 используется функция Fit[data, funs, vars], которая для списка данных data ищет приближение методом наименьших квадратов в виде линейной комбинации функций funs переменных vars. Примеры ниже иллюстрируют приближение исходных данных степенным полиномом и линейной комбинацией двух функций:

Fit[{{0,0.9},{2,8.1},{3,17},{4,33}},{1,x,x2},x]
0.997273-1.40864х+2.33409х²
Fit[{{0,0.9},{2,8.1},{3,17},{4,33}},{x,x2,Exp[x]},x]
0.274772е^х+1.63939х+0.717496х²

На рис. 9.23 показан несколько иной путь проведения полиномиальной аппроксимации — исходные данные заданы объектом-списком data.

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

Мах[1,5,2,6.5,3,4]
6.5
Мах[{1,3,2},{4,5,6},{9,8,7}]
9
Min[1,5,2,6.5,-3,4]
-3
Min[{1,3,2},{4 5 6},{9,8,7}]
1

Если нужен поиск локального минимума некоторой аналитической функции, используется функция FindMinimum[f, {х, х0}]. Она выполняет поиск (начиная со значения х=х0) и возвращает значение локального минимума f. Чтобы задать градиент функции, для которой выполняется поиск минимума, используется параметр Gradient. Приведем примеры применения функции FindMinimum:

FindMinimum[-5x Exp[-x/2](2+Sin[3x],{x,1})
{-7.17833,{х->0.783139}
FindMinimum[100(y-x2)2+(1-x2)2,{x,0},{y,0},AcuracyGoal->Automatic]
{9.90511´ 10^-13,{х->1.,у->0.999999}}

Следующие две функции служат для поиска глобального максимума и минимума аналитически заданной функции: ConstrainedMax[f, {inequalities}, {х, у, ...}] — ищет глобальный максимум функции f в области, определяемой неравенствами inequalities; ConstrainedMin[f, {inequalities}, {х, у,...}] — ищет глобальный минимум функции f в области, определяемой неравенствами inequalities. Все переменные х, у, ... полагаются неотрицательными. Эти функции решают типовые задачи линейного программирования. Может использоваться функция Linear Programming[c, m, b]. Она ищет вектор х, минимизирующий величину с. х в соответствии с условиями m.х >= b и x >= 0.

ConstrainedMax[
    4*х1+3*х2+2*х3,
    {х1>=20,х2>=20,х3>=20,
    4*х1+3.4*х2+2*хЗ<=340,
    4.75*х1+11*х2+2*хЗ<=700,
    х1+х2+х3==100},
    {х1,х2,х3}]
{332.,х1® 56.,х2® 20.,х2® 24.}

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

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

Y:=Array[Exp,4]
Y
{Е, Е² , Е³ , Е⁴}
N[Y]
{2.71828, 7,38906, 20.0855, 54.5982}
Array[f,{3,3}]
{{f[i,1],f[i,2],f[1,3]},
{f[2,1],f[2,2],f[2,3]},
{f[3,1],f[3,2],f[3,3]}}
Array[Sin,3,0]
{0,Sin[1],Sin[2]}
Array[Sin,4,1,Plus]
Sin[1]+Sin[2]+Sin[3]+Sin[4]
Array[f,5,2,2]
2[f[2],f[3],f[4],f[5],f[6]]

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

A:=MentityMatrix[3]
A
{{1,0,0},{0,1,0},{0,0,1}}
MatrixExp[A]
{{Е,0,0},{0,Е,0},{0,0,Е}}
MatrixQ[A]
True
MatrixPower[MatrixExp[A],-1.5]
{{0.22313,0,0},{0,0.22313,0},{0,0,0.22313}}
А+{{1,2,3),{4,5,6},(7,8,9}}
{{1,2,3},{4,6,6},{7,8,10}}
m:={{1,2},{3,7}}
MatrixForm[m]
1  2
3  7
Det[m]
1
Inverse[m]
{{7,-2},{-3,1}}
MatrixQ[m]
True
RowReduce[m]
{{1,0},(0,1}}
m = {{1,2},{3,7}}
{{1,2},{3,7}}
Transpose[m]
{{1,3},{2,7}}
Inverse[{1,2},{3,7}]
{{7,-2},{-3,1}}

Приведем примеры на решение систем линейных уравнений матричными методами. В первом из них решение выполняется в символьном виде на основании формулы Х=А^-1В, где А — матрица коэффициентов системы линейных уравнений, В — вектор свободных членов. Для перемножения используется функция Dot, а для инвертирования матрицы — функция Inverse:

A:={a,b,c,d}
B:={e,f}
X:=Dot[Inverse[A],B]
X

Во втором примере для вычисления неизвестных системы линейных уравнений используется функция LinearSolve:

А={{1+2I,2+3I},{3+4I,4+5I}}
{{1+2I,2+3I}, {3+4I,4+5I}}
В={2I,3}
{2I,3}
X=LinearSolve[A,B]

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

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

F[x_]=2*x^2
2 х²
F[a]
2 а²
a//F
2 а²
f[x_,y_]=x^2+y^2
x²+y²
f[a,b]
a²+b²
а^~f^~b
a²+b²

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

Denominator[(x+1)/(x^2+2*x+3)]
3+2х+х²
expr=a*b+c-d
ab+c-d
First[expr]
ab
Last[expr]
-d
Rest[expr]
c-d

Иногда возникает необходимость в удалении части выражения. Для этого применяется функция Delete[expr, n]. Она удаляет элемент на позиции n в выражении ехрr. Если n отрицательно, позиция отсчитывается с конца. Есть и ряд других форм этой функции.

Appiy[f,{a,b,х}]
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,{a,b,c}]
{f[a],f[b],f[c]}
MapAll[f,a*x+b]
f[f[b]+f[f[a]f[x]]]

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

Основной функцией упрощения выражений expr является функция Simplify[expr]:

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

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

Приведем примеры на функции расширения выражений Expand:

Expand[(x-a)*(x-b)*(x-c)]
-abc + abx + acx + box - ax² - bx² - cx² + x³
Expand[2*Cos[x^2,Trig->True]]
2Cos[x]²
Expand[Sin[x]^2+Cos[x]^2]
Cos[y]²+Sin[x]²
ExpandAll[Sin[2*Cos[x]],Trig->True]
Cos[Cos[x]+Isin[x]]Sin[Cos[x]-Isin[x]]+
Cos[Cos[x]-Isin[x]]Sin[Cos[x]+Isin[x.]]
ExpandNumerator[(1+x)^2/x]

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

ComplexExpand[Sin[a+I*b]]
Cosh[b]Sin[a]+Icos[a]*Sinh[b]
PowerExpand[Sqrt[a^2*b*c]]

FunctionExpand[Zeta[3, 2+x]]

К функциям, расширяющим выражения, относятся также функция Collect[expr, х], которая выполняет приведение общих членов выражения по степеням переменной х, и функция Collect[expr, {х1, х2, ...}], которая выполняет приведение общих членов выражения по степеням переменных х1, х2,... Эта функция особенно полезна, если результат можно представить в виде степенных многочленов:

Collect[(х-1)*(х-2)*(х^2-9),х]
-18+27х-7х²-3х³+х⁴
Collect[a*x^2+b*x*y_c*y+d*y^2,x]
ax²+cy+bxy+dy²
Collect[a*x^2+b*x*y+c*y+d*y^2,у]
ax²+(c+bx)y+dy²

В другом примере показано применение функции Collect к выражению с двумя переменными:

Collect[(x-1)*(y-3)*(x-2)*(y-2)*(x-1),y,x]
-12+30х-24х²+6х³+(10-25х+20х²-5х³)у+(-2+5х-4х²+х³)у²

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

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

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

expr=TrigExpand[Sin[a+b]^3];
TrigFactor[expr]
Sin[a+b]³
TrigFactоrList[ехрr]
{{1,1},{Sin[a+b],3}}
Trig Expand[Cosh[Sin[x*y]]]

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

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

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

Factor[х^3-6*х^2+11*х-6]
(-3+х)(-2+х)(-1+х)
Factor[x^3-6*x^2+21*x-52]
(-4+x)(13-2x+x²)
Factor[x^5+8^x^4+31*x^3+80*x^2+94*x+20,Modulus->3]
(1+х)²(2+х)³
FactorList[x^4-1,Modulus->2]
{{1,1},{1+х,4}}
FactorSquareFree[(x^2+1)*(x^4-1)]
(-1+х²)(1+х²)²
FactorTerms[2*x^2+4*x+6]
2(3+2x+x²)
FactorTermsList[2*x^2+4*x+6]
{2,3+2x+x²)
Factorlnteger[123456789]
{{3, 2},{3607,1},{3803,1}}

Функция Factor с параметром Trig->True может работать и с тригонометрическими выражениями:

Р[х]:=a*x^3+b*x^2+c*x+d
Q[x]:=e*x^2-f*x-1
Null²
Collect[P[x]+Q[x],x]
-1+d+(c-f )x+(b+e)x²+ax³
Collect[P[x]*Q[x],x]
-d+(-c-df)x+(-b+de-cf )x²+(-a+ce-bf)x³+(be-af )x⁴+aex⁵
PolynomialQ[P[x]+Q[x]]
True
Decompose[P[x],x]
{d+cx+bx²+ax³}
PolynomialQuotient[P[x],Q[x],x]

PolynomialRemainder[Q[x],P[x],x]
-1-fx+ex²
CoefficientList[P[x],x]
{d,c,b,a}
Decompose[x^6+x+1-x^3+2*x^5,x]
{1+х-х³+2х⁵+х⁶}
PolynomialGCD[P[x],Q[x]]
1
PolynomialLCM[P[x],Q[x]]
P[x]Q[x]
PolynomialQuotient[3*x^3-2*x^2+x,x^2-x+1,x]
1+3x
PolynomialRemainder[3*x^3-2*x^2+x,x^2-x+1,x]
-1-х
Reduce[a*x^2+b*x+c==0,x]

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

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

Столь же естественно язык системы реализует ставшее модным в последнее время объектно-ориентированное программирование. В его основе лежат три важнейших понятия: инкапсуляция — объединение в одном объекте как данных, так и методов их обработки; наследование — означает, что каждый объект, производный от других объектов, наследует их свойства, и полиморфизм — свойство, позволяющее передать ряду объектов сообщение, которое будет обрабатываться каждым объектом в соответствии с его индивидуальными особенностями. Приведённый ниже пример объектно-ориентированного программирования дает три определения, ассоциированные с объектом h:

Средства языка Mathematica позволяют осуществить и визуально-ориентированное программирование. Его смысл заключается в автоматической генерации программных модулей путем указания визуально понятного объекта — чаще всего кнопки. Mathematica позволяет создавать палитры и панели с различными кнопками, предназначенными для управления программой или ввода новых программных объектов. Однако визуально-ориентированное программирование пока не является основным. Достаточно средств язык Mathematica 4 предоставляет и для реализации операторного и процедурного программирования.

Иногда может потребоваться задание некоторой функции только в момент ее создания. Эта функция представляется только выражением без имени — отсюда и ее название — чистая функция. Для создания такого объекта служит встроенная функция Function[body]. Она создает чистую функцию с телом body. Function [{x}, body] — создает чистую функцию параметра х с телом body и Function[{x1, х2, ,..}, body] — создает чистую функцию ряда параметров х1, х2,... с телом body.

Function[{x,n}, х^n]
Function[{x,n}, хⁿ]
%[2,3]
8

Function[{x,n}, x^n]
Function[{x, n}, хⁿ]
{f[2,3],f[z,y]}
{8, z^y}

Предельно компактную форму задания функций имеют так называемые анонимные функции. Они не имеют ни названия, ни обычного определения и задаются только выражениями специального вида. В этом выражении вместо переменных используют обозначения # (для одной переменной), #1, #2,... — для ряда переменных. Завершается тело функции символом &. Примеры:

#1^#2&[2,3]
8
#1^#2&[y,z]
У^Z

Nest[Exp[x],x,5]
Ех[Ех[Ех[Ех[Ех[х]]]]]
NestList[f,x,3]
{x,f[x],f[f[x]],f[f[f[x]]]}
Fold[f,x,{1,2,3}]
f[f[f[x,1],2],3]
FoldLisy[f,x,{1,2,3}]
{x.f[x,1],f[f[x,1],2],f[f[f[x,1],2]3]}
ComposeList[{Exp,Ln,Sin},x]
{x,E^x,Ln[E^x],Sin[Ln[E^x]]}

Для создания подобия циклов может использоваться функция FixedPoint[f,ехрr]. Она вычисляет выражение ехрr и применяет к нему функцию f, пока результат не повторится. Есть еще одна ее форма, FixedPoint[f, ехрr, SameTest->comp], которая вычисляет ехрr и применяет к нему f, пока два последующих результата не дадут True в тесте. Пример применения функции FixedPoint:

Последний результат (0) выводится в отдельной (нумерованной) ячейке вывода и означает завершение процесса итераций — деления t на 2. Следующий пример иллюстрирует, как можно создать цепную дробь с помощью функции Nest:

Nest[Function[t,1/(1+t)],у,3]

Еще одна функция такого рода — Catch[expr] — вычисляет expr, пока не встретится Throw[value], затем возвращает value. Одна имеет формы: Catch[expr, form] — вычисляет expr, пока не встретится Throw[value, tag], затем возвращает value, и Catch[expr, form, f] — возвращает f[value, tag] вместо value. Ниже представлены некоторые конструкции циклов с функцией Catch:

Catch[x,a,f]
х
Catch[Throw[х,у], у, fun]
fun[x,у]
Catch[NestList[1/(# + 1)&, -3., 5]]
{-3,-0.5,2.,0.333333,0.75,0,571429}

В следующих примерах показано вычисление квадратного корня из числа 5 по известному алгоритму Ньютона, записанному в виде функции newton5:

newton5[x_] := N[1/2(х + 5/х)]
Nest[newton5,1/0,5]
2.23607
NestList[newton5,1/0,5]
{1.,3.,2.33333,2.2381,2.23607,2.23607}
FixedPoint[newton5, 1.0]
2.23607
FixedPointList[newton5, 1.0, SameTest -> (Abs[#1 - #2] < 10.^-4 &)]
{1.,3.,2.33333,2.2381,2.23607,2.23607}

Обратите внимание на то, что функции Nest и FixedPoint дают единственный конечный результат, тогда как функции NestList и FixedPointList возвращают еще и все промежуточные результаты итераций. Последний пример иллюстрирует остановку вычислений по заданной погрешности, равной 10^-4.

Далее зададим функцию, реализующую алгоритм Ньютона для нахождения корня произвольного выражения f(х) при начальном значении x₀=a по формулам х₀=а и

Тогда вычисления корня из выражения е^х-2 с начальным приближением х₀=0.5 и числом итераций n можно организовать с помощью функций Nest и NestList:

В первом случае возвращается последний результат, а в других — все промежуточные. Функция FixedPoint позволяет осуществлять итерацию до тех пор, пока результат не перестанет изменяться (с машинной точностью). Это иллюстрирует следующий пример:

r=(1+х)^2;r=Expand[r];r-1
2х + х²

Для задания процедуры со списком локальных переменных {а, b, ...} и телом рroc может использоваться функция Module[ {а, b, ...}, рroc]. Однако для создания полноценных процедур и функций, которые могут располагаться в любом числе строк, может использоваться базовая структура: Block[{x, у, ...}, procedure] — задание процедуры с объявлением списка локальных переменных х, у,... и Block [{х = х0, у=у0, ...}, procedure] — задание процедуры с объявлением списка переменных х, у,... с заданными начальными значениями. Пример использования базовой структуры:

Полезно разобраться со статусом переменной u в этом примере.

Хорошо известные циклы Do в Mathematica строятся следующим образом:

Примеры организации цикла Do и его исполнения представлены ниже:

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

Здесь используются два цикла с управляющими переменными i и j. Командой Print выводятся значения переменных i и j, а также их суммы i+j. Следующий пример иллюстрирует применение цикла Do для задания функции, вычисляющей n-е число Фибоначчи:

Обратите внимание на применение в этом примере функции Module. Она создает программный модуль с локальными переменными (в нашем случае fn1 и fn2), в котором организовано рекуррентное вычисление чисел Фибоначчи.

Другой вид циклов — цикл For — реализуется функцией For[start, test, incr, body]. В ней внутренняя управляющая переменная вначале приобретает значение start, затем циклически меняется от этого значения до значения body с шагом изменения incr и так до тех пор, пока условие test не перестанет давать логическое значение True. Когда это случится, то есть test даст False, цикл заканчивается. Пример:

Программа, приведенная выше, позволяет наблюдать за изменением значений управляющей переменной цикла i и переменной х, получающей за каждый цикл приращение, равное 5*i. В конце документа показан пример на использование функции возвращения значений Return[x]. В цикле For не предусмотрено задание локальных переменных, поэтому требуется следить за назначением переменных — при использовании глобальных переменных возможны побочные эффекты.

Итак, функция For позволяет создавать циклы, которые завершаются при выполнении какого-либо условия. Такие циклы можно организовать и с помощью функции While[test, expr], которая выполняет выражение expr до тех пор, пока test дает логическое значение True. Ниже дан пример организации и использования цикла While:

Цикл While, в принципе, может заменить другие рассмотренные выше циклы. Однако это усложняет запись и понимание программ. Аппарат локальных переменных в этом типе циклов не используется.

Как у большинства языков программирования, условные выражения задаются с помощью инструкции или функции If. В системе Mathematica имеются следующие функции If:

Следующий пример поясняет задание программной процедуры с циклом Do, выход из которой задается с помощью функции If и директивы прерывания Aborted[]:

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

Which[1==2,1,2==2,2,3==3,3]
2
Which[1==2,х,2==2,у,3==3,z]
У
Which[3,1,a,2,b,3,c]
с
Swhich[8,1,a,2,b,3,c]
Swith[8,
      1,  а,
      2,  b,
      3,  с]

Switch[8.,1.5,a,2.5,b,8/,с]
с
Switch[1.5,1.5,a,2.5,b,8/,c]
а
Switch[8,1.5, а,2.5,b,8/,с]
Swith[8, 1.5, а,
      2.5, b,
      8., с]

В Mathematica 4 на всякий случай сохранена инструкция безусловного перехода Goto[tag], которая обеспечивает переход к тому месту программы, которое отмечено меткой Label[tag]. Возможны также формы Goto[expr] и Label[expr]. Применение инструкции Goto иллюстрирует следующий пример:

Интересной особенностью языка программирования Mathematica является возможность создания переходов по значению вычисляемого выражения:

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

Чисто внешне контекст задается в виде Имя_контекста'. Апостроф в конце имени и есть признак контекста (он является и разделителем). Один и тот же контекст может принадлежать разным объектам. Например, все системные переменные и встроенные функции имеют контекст System', то есть они относятся к системным объектам, а все символы, вводимые в начале работы с системой, имеют контекст Global' (глобальные).

В системе Mathematica есть средства для визуализации контекстов. Прежде всего это функция Context:

Текущее значение контекста определяет системная переменная $Context иди функция Context[]:

В начале сеанса работы по умолчанию действует контекст Global':

Обратите внимание на то, что символы new'q и new'wq'х имеют свой новый контекст new' и отображаются вместе с ним (но контекст указан перед символом). А вот символ Global' r отображается лишь кратким именем. Причина этого в том, что текущий контекст есть Global', а контекст new отсутствует на так называемой контекстной дорожке, проще говоря, списке контекстов. Что касается символов q, r и z, то сами по себе (без новой контекстной приставки) они по-прежнему имеют контекст Global':

Для вывода контекстной дорожки используется переменная $ContextPath:

С помощью функции Prepend можно добавить в контекстную дорожку новый контекст, например new':

Теперь функция Context возвращает только контексты символов new'q, new'w и Global'r:

С помощью функции Begin можно изменить текущий контекст на заданный, например Global' на new':

Для получения списка всех определений с заданным контекстом можно использовать функцию Name["Context'S"], где S — символ (или строка), определяющий имена определений. Например, для получения всех определений с контекстом System' можно использовать функцию Name["System'*].

Функция Name[] без параметра выводит полный список всех определений как для ядра, так и для пакетов расширений с указанием их контекстов. Таким образом, данная функция позволяет получить самую полную информацию об определениях (функциях, константах и т. д.), которые имеет текущая версия системы Mathematica.

Приведем пример простого фрагмента программы, дающего определение новой функции ExpandBoth с помощью некоторых из представленных средств:

Ниже представлен сеанс работы с этим пакетом, файл которого expboth.m размещен в подпапке mypack общей папки пакетов расширений:

В практике подготовки и отладки программ важное значение имеет наличие специальных средств отладки программ по шагам — средств трассировки. Функция Тrасе[ехрr] позволяет выполнить трассировку выражения ехрr. Возьмем простой пример — вычисление выражения 2*(3+4)²/5:

Тrасе[2(3+4)2/5]

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

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

<<mypack\rk4.m
RKSolVe[{t*y+z,t+y*z},{у,z},{1,1},{t,1,1.5,0.1}]
{{1.,1.},{1.22754,1.22844},{1.52241,1.53202},
{1.90912,1.95373},{2.42456,2.77444},{3.12741,3.55937}}

Решение представлено списком значений {yi,zi}, определяющим зависимости у(t) и z(t). Этот пример хорошо иллюстрирует реализацию популярного численного метода для решения систем ДУ.