Министерство образования Республики Беларусь

УЧРЕЖДЕНИЕ ОБРАЗОВАНИЯ

«ГРОДНЕНСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ

ИМЕНИ ЯНКИ КУПАЛЫ»

МЕЖДУНАРОДНАЯ АКАДЕМИЯ НООСФЕРЫ

Балтийское отделение

В.З. АЛАДЬЕВ, В.К. БОЙКО, Е.А. РОВБА

ПРОГРАММИРОВАНИЕ И РАЗРАБОТКА ПРИЛОЖЕНИЙ В MAPLE

М о н о г р а ф и я

Гродно – Таллинн 2007

Аладьев В.З. Программирование и разработка приложений в Maple: монография /

В.3. Аладьев, В.К. Бойко, Е.А. Ровба.– Гродно: ГрГУ; Таллинн: Межд. Акад. Ноосферы, Балт. отд.– 2007, 458 с., ISBN 978-985-417-891-2 (ГрГУ), ISBN 978-9985-9508-2-1 (МАНУР)

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

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

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

Монография является одним из немногих изданий по программированию в среде пакета Maple, что и определяет ее место среди исследований по программным средствам для ПК, использующих операционную среду Windows. Вместе с тем мобильность пакета позволяет использовать его многими другими популярными платформами. Монография рассчитана на достаточно широкий круг специалистов, использующих в своей профессиональной деятельности ПК для решения задач математического характера, а также на студентов и учащихся, изучающих курс «Основы информатики и вычислительной техники» физико-математических и других естественнонаучных специальностей соответствующих университетов и колледжей.

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

Рецензент: доктор физико-математических наук, профессор А.Н. Дудин

ISBN 978-985-417-891-2 (ГрГУ) © Аладьев В.З. (Таллинн)

ISBN 978-9985-9508-2-1 (МАНУР) Бойко В.К., Ровба Е.А. (Гродно), 2007

Maple V, Maple 6, Maple 7, Maple 8, Maple 9, Maple 10 – торговые марки MapleSoft Inc.

Содержание

Предисловие 5

Глава 1. Базовые сведения по Maple-языку пакета 21

1.1. Базовые элементы Maple-языка пакета 23

1.2. Идентификаторы, предложения присвоения и выделения Maple-языка 30

1.3. Средства Maple-языка для определения свойств переменных 42

1.4. Типы числовых и символьных данных Maple-языка пакета 45

1.5. Базовые типы структур данных Maple-языка 51

1.6. Средства тестирования типов данных, структур данных и выражений 80

1.7. Конвертация Maple-выражений из одного типа в другой 89

1.8. Функции математической логики и средства тестирования пакета 93

Глава 2. Базовые управляющие структуры Maple-языка пакета 106

2.1. Предварительные сведения общего характера 106

2.2. Управляющие структуры ветвления Maple-языка (if-предложение) 108

2.3. Циклические управляющие структуры Maple-языка (while_do-предложение) 111

2.4. Специальные типы циклических управляющих структур Maple-языка 115

Глава 3. Организация механизма процедур в Maple-языке пакета 118

3.1. Определения процедур в Maple-языке и их типы 119

3.2. Формальные и фактические аргументы Maple-процедуры 126

3.3. Локальные и глобальные переменные Maple-процедуры 131

3.4. Определяющие параметры и описания Maple-процедур 138

3.5. Механизмы возврата Maple-процедурой результата ее вызова 150

3.6. Средства обработки ошибочных и особых ситуаций в Maple-языке 156

3.7. Расширенные средства Maple-языка для работы с процедурами 167

3.8. Расширение функциональных средств Maple-языка пакета 176

3.9. Иллюстративные примеры оформления Maple-процедур 184

3.10. Элементы отладки Maple-процедур и функций 205

Глава 4. Организация программных модулей в Maple-языке 213

4.1. Вводная часть 213

4.2. Организация программных модулей Maple-языка 216

4.3. Сохранение процедур и программных модулей в файлах 227

Глава 5. Средства Maple-языка для работы с данными и структурами строчного, символьного, списочного, множественного и табличного типов 235

5.1. Средства работы Maple-языка с выражениями строчного и символьного

типов 235

5.2. Средства работы Maple-языка с множествами, списками и таблицами 249

5.3. Алгебраические правила подстановок для символьных вычислений 265

5.4. Средства Maple-языка для обработки алгебраических выражений 273

5.5. Управление форматом вывода результатов вычисления выражений 305

Глава 6. Средства ввода/вывода Maple-языка 311

6.1. Средства Maple-языка для работы с внутренними файлами пакета 311

6.2. Средства Maple-языка для работы с внешними файлами данных 321

6.2.1. Открытие, закрытие и удаление внешних файлов любого типа 327

6.2.2. Средства обработки особой ситуации «конец файла» доступа к файлам 331

6.2.3. Обработка особых и ошибочных ситуаций процедур доступа к файлам 333

6.3. Базовые средства Maple-языка для обеспечения доступа к внешним

файлам данных TEXT-типа 335

6.3.1. Базовые средства доступа к файлам данных на уровне Maple-выражений 340

6.4. Средства Maple-языка для обеспечения доступа к внешним файлам данных

BINARY-типа 343

6.5. Обеспечение форматированного доступа к внешним файлам данных 345

Глава 7. Графические средства Maple-языка пакета 352

7.1. Графическая интерпретация алгебраических выражений и уравнений

в среде Maple-языка 352

7.2. Двухмерное представление функциональных зависимостей и данных

в среде Maple-языка 354

7.3. Трехмерное представление функциональных зависимостей и данных

в среде Maple-языка 373

7.4. Создание графических объектов на основе базовых примитивов 383

Глава 8. Создание и работа с библиотеками пользователя 392

8.1. Классический способ создания Maple-библиотек 393

8.2. Специальные способы создания библиотек пользователя в среде Maple 415

8.3. Создание пакетных модулей пользователя 426

8.4. Статистический анализ Maple-библиотек 436

9. Средства Maple, не рассматриваемые в настоящей книге,

но полезные для приложений 444

Заключение 443

Литература 448

Справка по авторам 453

Предисловие

Системы компьютерной алгебры (СКА) находят все более широкое применение во многих областях науки таких как математика, физика, химия, информатика и т.д., техники, технологии, образовании и т.д. СКА типа Maple, Mathematica, MuPAD, Macsyma, Reduce, Axiom и Magma становятся все более популярными для решения задач преподавания математически ориентированных дисциплин, как в научных исследованиях, так и в промышленности. Данные системы являются мощными инструментами для ученых, инженеров и педагогов. Исследования на основе СКА-технологии, как правило, сочетают алгебраические методы с продвинутыми вычислительными методами. В этом смысле СКА – междисциплинарная область между математикой и информатикой, в которой исследования сосредотачиваются как на разработке алгоритмов для символьных (алгебраических) вычислений и обработки на компьютерах, так и на создании языков программирования и программной среды для реализации подобных алгоритмов и базирующихся на них проблем различного назначения.

В серии наших работ [1-20,22-33,39,41-46,47,49,50,91,103] довольно детально рассмотрены такие математические пакеты как Maple, Reduce, MathCAD, Mathematica. При этом, особое внимание нами уделелялось особенностям каждого из пакетов, его преимуществам, а также недостаткам, эффективным приемам и методам программирования в его среде, созданию набора средств, расширяющих его возможности, а также выработке системы предложений по его дальнейшему развитию. Наш опыт апробации и использования четырех математических пакетов Mathematica, Reduce, Maple, MathCAD в различных математических и физических приложениях позволяет нам рассматривать именно пакеты Maple и Mathematica в качестве бесспорных лидеров (на основе специального обобщенного индекса) среди всех известных на сегодня современных СКА. При этом, мы предпочитаем именно пакет Maple (несмотря на все его недостатки и недоработки) из-за целого ряда преимуществ, среди которых особо следует выделить такие как развитые графические средства, достаточно эффективные средства решения систем дифференциальных уравнений, средства создания графических интерфейсов пользователя, мощная библиотека математических функций, большой набор сопутствующих пакетных модулей для различных приложений, современный встроенный язык программирования (4GL) интерпретирующего типа, интерфейс с рядом других Windows-приложений, перспективная концептуальная поддержка.

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

Между тем, наш эксплуатационный опыт в течение 1997–2006 г.г. с пакетом Maple релизов 4 – 10 позволил нам не только оценить его преимущества по сравнению с другими подобными пакетами, но также выявил ряд ошибок и недостатков, устраненных нами. Кроме того, пакет Maple не поддерживал ряд достаточно важных процедур обработки информации, алгебраических и численных вычислений, включая средства доступа к файлам данных. Ввиду сказанного, в процессе работы с пакетом Maple мы создали достаточно много эффективного программного обеспечения (процедуры и программные модули), целым рядом характеристик расширяющих базовые и по выбору возможности пакета. Данное программное обеспечение было организовано в виде Библиотеки, которая является структурно подобной главной библиотеке Maple и обеспечена развитой справочной системой, аналогичной подобной системе пакета Maple и весьма органично с ней связанной. Комментированное описание данной Библиотеки представлено в нашей книге [103]. К ней же прилагается данная Библиотека версии 2.1810, тогда как обновленную версию данной Библиотеки можно бесплатно загружать с любого из адресов, указанных в [109]. Демонстрационная же версия Библиотеки находится по адресу [108].

При этом, программные средства, составляющие Библиотеку, в своем большинстве имеют дело именно с базовой средой Maple, что пролонгирует их актуальность как на текущие релизы, начиная с шестого, так и на последующие релизы пакета. В этой связи здесь уместно обратить внимание на один весьма существенный момент. При достаточно частом объявлении о новой продукции MapleSoft, между тем, уделяет недостаточно внимания устранению имеющихся ошибок и дефектов, переходящих от релиза к релизу. Некоторые из них являются достаточно существенными. Мы отмечали данное обстоятельство в наших книгах неоднократно, этому вопросу посвящен целый ряд замечаний и членов MUG (Maple Users Group). Более того, расширению инструментальных средств основной среды пакета также уделяется недостаточное внимание, что особенно заметно в режиме продвинутого программирования в его среде. Представленная в [103] Библиотека содержит расширения инструментальных средств, прежде всего, базовой среды пакета, что пролонгирует их актуальность и на последующие релизы пакета, а также весьма существенно упрощает программирование целого ряда задач в его среде и обеспечивает более высокий уровень совместимости релизов 6 - 10. Выявленная нами несовместимость пакета как на уровне релизов, так и на уровне базовых операционных платформ – Windows 98SE и ниже, с одной стороны, и Windows ME/2000/XP и выше, с другой стороны, потребовала решения проблемы совместимости и для средств нашей Библиотеки относительно релизов 6 - 10.

В заключение данной преамбулы вкратце изложим (адресуясь, прежде всего, к нашим достаточно многочисленным читателям как настоящим, так и будущим) наше личное мнение по сравнительной оценке пакетов Maple и Mathematica. Как один, так и другой пакеты изобилуют многочисленными ошибками (в целом ряде случаев недопустимыми для систем подобного рода), устранению которых разработчиками как MapleSoft Inc., так и Wolfram Research уделяется сравнительно небольшое внимание. Из коммерческих соображений часто весьма необоснованно выпускаются новые релизы, сохраняющие старые ошибки и привнося в ряде случаев как новые ошибки, так и различного рода экзотические излишества. Данный вопрос неоднократно поднимался как в наших изданиях, так и перед разработчиками. Однако, если разработчики Maple в режиме открытого диалога с пользователями в какой-то мере пытаются решить данную проблему, то Wolfram Research достаточно болезненно воспринимает любую (в подавляющем большинстве обоснованную) критику в свой адрес. При этом, Wolfram Research ведет весьма агрессивную маркетинговую политику, не вполне адекватную качеству ее продукции. Именно это, прежде всего, объясняет ее временные количественные преимущества, которые достаточно быстро уменьшаются. Сравнивая отклики пользователей пакетов Maple и Mathematica, а также в свете нашего многолетнего опыта работы с обоими пакетами, можно вполне однозначно констатировать, что вторые при использовании пакета имеют значительно больше проблем.

Из нашего опыта достаточно глубокого использования и апробирования обоих пакетов отметим, что Maple – существенно более дружелюбная и открытая система, использующая достаточно развитый встроенный язык 4-го поколения интерпретирующего типа, что упрощает освоение пакета пользователю, имеющему опыт современного программирования. Тогда как пакет Mathematica имеет несколько архаичный и не столь изящный язык, в целом ряде отношений отличный от современных языков программирования. Наконец, Maple имеет по ряду показателей более развитые инструментальные средства (например, для решения диффуравнений в частных производных, предоставления используемого алгоритма решения задачи, настройки графического интерфейса пользователя на конкретные приложения и др.), а также весьма широкий спектр бесплатных приложений во многих фундаментальных и прикладных областях современного естествознания.

Пакет Maple воплощает новейшую технологию символьных вычислений, числовых вычислений с произвольной точностью, наличие инновационных Web-компонент, расширяемой технологии пользовательского интерфейса (Maplets), и весьма развитых математических алгоритмов для решения сложных математических задач. В настоящее время пакет использует более 5 миллионов студентов, ученых, исследователей и специалистов из различных областей. Практически каждый ведущий университет и научно-исследовательский институт в мире, включая такие, как MIT, Cambridge, Stanford, Oxford, Waterloo и др., используют пакет для учебных и исследовательских целей. В промышленных целях пакет используется такими ведущими корпорациями как Boeing, Bosch, Canon, Motorola, NASA, Toyota, Hewlett Packard, Sun, Microsystems, Ford, General Electric, Daimler-Chrysler и др.

Резюмируя сказанное (более детальный сравнительный анализ обоих пакетов можно найти в серии наших работ [1-20,22-33,39,41-46,47,49,50,91,103]), начинающему пользователю систем компьютерной алгебры рекомендуем все же пакет Maple, как наиболее перспективное средство в данной области компьютерной математики. Этому существенно способствует и творческий альянс MapleSoft с всемирно известным разработчиком математического ПО – NAG Ltd. И это при том, что последний имеет и свою довольно приличную СКА – AXIOM, являющуюся на сегодня лидером среди СКА на европейском уровне. При этом, Maple постоянно отвоевывает позиции у Mathematica и начинает доминировать в образовании, что весьма существенно с ориентацией на перспективу; используемая Mapleидеология занимает все более существенное место при создании различных электронных материалов математического характера.

Вместе с тем, современное развитие пакета Maple вызывает и ряд серьезных опасений, которые в общих чертах можно определить следующим образом. Качество любого программного обеспечения определяется в соответствии с большим количеством характеристик, среди которых можно отметить такие существенные как: (1) совместимость программных средств «снизу-вверх», (2) устойчивость функционирования относительно операционных платформ, наряду с качественной поддержкой и сопровождением, и т. д. Данным критериям последние релизы пакета Maple, начиная с 7-го, удовлетворяют все меньше и меньше, а именно.

Достаточно существенные ошибки и недоработки (многие из них неоднократно отражались в наших книгах и статьях, а также в ряде других источниках, включая многочисленные форумы по Maple) переходят от релиза к релизу. Отсутствует совместимость релизов пакета Maple «снизу-вверх». О несовместимости релизов Maple мы неоднократно отмечали в своих книгах и статьях. Кое-что для усовершенствования совместимости нами было сделано (в частности, посредством нашей Библиотеки, представленной в [103,109]), однако не все. Тем временем, для Maple релизов 9 и 10 была обнаружена несовместимость уже среди их клонов. Как хорошо известно, Maple 9 и 10 поддерживают два режима – классический (например, для Maple 9 ядро “cwMaple9.exe”и для Maple 10 ядро “cwMaple.exe”) и стандартный (например, для Maple 9 ядро `Maplew9.exe` и для Maple 10 ядро Maplew.exe). Оказывается, что данные клоны несовместимы даже на уровне встроенных функций.

В частности, если в классическом режиме встроенная функция system выполняется корректно, то в стандартном режиме, возвращая код завершения 0, она некорректно выполняет некоторые команды (программы) MS DOS. По этой причине процедуры нашей Библиотеки, использующие данную функцию и отлаженные в Maple релизов 8 и ниже, а также в классическом режиме Maple 9-10, в стандартном режиме Maple 9-10 выполняются некорректно, часто вызывая непредсказуемые ошибочные ситуации. В целях устранения подобных ситуаций нами была определена процедура System, заменяющая указанную стандартную функцию system и устраняющая ее основные недостатки [103]. Естественно, подобные нарушения требований к качественному программному обеспечению не допустимы для программных средств подобного типа и могут вести к нежелательным для Maple последствиям. Более того, нам кажется, что их действие уже начинает сказываться.

Ввиду сказанного, упомянутая наша Библиотека корректно работает с Maple релизов 6 - 8 и Maple 9 - 10 (классический режим), тогда как для Maple 9 - 10 (стандартный режим) некоторые библитечные средства, использующие стандартную функцию system, будут выпоняться некорректно или вызывать ошибочные ситуации, в ряде случаев непредсказуемые. В этой связи заинтересованный читатель в качестве достаточно полезного упражнения имеет хорошую возможность использовать процедуру System для обновления упомянутых процедур Библиотеки на предмет расширения сферы их применимости и на стандартный режим Maple. В целях большей информативности приведем краткую характеристику нашей Библиотеки [103,108,109].

Характеристика нашей библиотеки программных средств . Упоминаемая здесь Библиотека расширяет диапазон и эффективность использования пакета Maple на платформе Windows благодаря содержащимся в ней средствам в трех основных направлениях: (1) устранение ряда основных дефектов и недостатков, (2) расширение возможностей ряда стандартных средств, и (3) пополнение пакета новыми средствами, расширяющими возможности его программной среды, включая средства, повышающие уровень совместимости релизов 6 - 10 пакета, о которой говорилось выше. Основное внимание было уделено дополнительным средствам, созданным нами в процессе использования пакета Maple релизов 410, которые по целому ряду параметров существенно расширяют возможности пакета и облегчают работу с ним. Значительное внимание уделено также средствам, обеспечивающим повышение уровня совместимости пакета релизов 6-10. Большой и всесторонний опыт использования данного программного обеспечения подтвердил его высокие эксплуатационные характеристики при использовании пакета Maple в многочисленных приложениях, потребовавших не только стандартных средств, но и программирования своих собственных, ориентированных на конкретные приложения.

Со всей определенностью следует констатировать, что серия наших книг по Maple [29-33, 39,41-46,91,103], представляющая разработанные нами средства и содержащая предложения по дальнейшему развитию пакета, в значительной степени стимулировала появление таких полезных приложений как пакетные модули ListTools, FileTools, StringTools и LibraryTools. Между тем, и в свете данных приложений средства нашей Библиотеки существенно расширяют возможности пакета, во многих случаях перекрывая средства указанных пакетных модулей. Текущая версия Библиотеки содержит набор средств (более 730 процедур и программных модулей), ориентируемых на следующие основные виды обработки информации и вычисления [103,108,109]:

1. Программные средства общего назначения

2. Программные средства для работы с процедурными и модульными объектами

3. Программные средства для работы с числовыми выражениями

4. Программныее средства для работы со строчными и символьными выражениями

5. Программные средства для работы со списками, множествами и таблицами

6. Программное обеспечение поддержки структур данных специального типа

7. Программное обеспечение для по-битной обработки информации

8. Программные средства, расширяющие графические возможности пакета

9. Расширение и исправление стандартного программного обеспечения Maple

10. Программное обеспечение для работы с файлами данных

10.1. Программное обеспечение общего назначения

10.2. Программное обеспечение для работы с текстовыми файлами

10.3. Программное обеспечение для работы с бинарными файлами

10.4. Программное обеспечение для работы с файлами Maple

10.5. Специальное программное обеспечение для работы с файлами данных

11. Программное обеспечение для решения задач математического анализа

12. Программное обеспечение для решения задач линейной алгебры

12.1. Программное обеспечение общего назначения

12.2. Программное обеспечение для работы с rtable-объектами

13. Программное обеспечение для решения задач простой статистики

13.1. Программное обеспечение для решения задач описательной статистики

13.2. Программное обеспечение для решения задач регрессионного анализа

13.3. Программное обеспечение для проверки статистических гипотез

13.4. Элементы анализа временных (динамических) и вариационных рядов

14. Программное обеспечение для работы с библиотеками пользователя

Основные новации нашей Библиотеки с привязкой к вышеперечисленным разделам, тематически классифицирующим средства Библиотеки, кратко охарактеризованы в Предисловии к нашей книге [103] и на web-страницах www.aladjev.narod.ru/MapleBook.htm и www.exponenta.ru/educat/news/aladjev/book2.asp. Исходя же из нашего многолетнего опыта использования пакета Maple релизов 4 - 10 и опыта наших коллег из университетов и академических институтов России, Эстонии, Белоруссии, Литвы, Латвии, Украины, а также ряда других стран, следует отметить, что многие из средств (или их аналоги) нашей Библиотеки весьма целесообразно включить в стандартные поставки последующих релизов пакета Maple. Соответствующие предложения были нами представлены разработчикам пакета. При этом, можно констатировать, что ряд наших книг по Mapleпроблематике, которые представляют средства, разработанные нами, и содержат полезные рекомендации по дальнейшему развитию пакета, стимулировали появление модулей FileTools, ListTools, LibraryTools и StringTools. Однако, в этом отношении средства, представленные нами, существенно расширяют возможности пакета, во многих случаях превышая таковые из указанных пакетных модулей. В настоящее время они доступны пользователям Maple в виде предлагаемой Библиотеки, функционирующей на платформах Windows и поддерживающей релизы 6-10 пакета. Данная Библиотека прилагается к нашей книге [103], а также может быть получена по адресу [109]. Средства Библиотеки в целом ряде случаев позволяют существенно упрощать программирование различных прикладных задач в среде пакета Maple релизов 6 - 10. Настоящая Библиотека была отмечена в 2004 г. наградой Smart Award от Smart DownLoads Network.

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

Библиотека структурно подобна главной библиотеке Maple, снабжена развитой справочной системой по средствам, расположенным в ней, и логически связана с главной библиотекой пакета, обеспечивая доступ к средствам, содержащимся в ней, подобно стандартным средствам пакета. Простое руководство описывает установку Библиотеки при наличии на компьютере с платформой Windows инсталлированного пакета Maple релизов 6, 7, 8, 9, 9.5 и/или 10. Для полной установки данной Библиотеки требуется 17 МB свободного пространства на жестком диске. Сопутствующие материалы содержат немало дополнительной полезной информации, которая по тем либо иным причинам не была включена в основной текст книги.

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

Следует отметить, что поставляемые с Библиотекой файлы “ProcUser.txt” (для Maple 6–9) и “ProcUser10.txt” (для Maple 9.5/10), содержащие исходные тексты программных средств, составляющих Библиотеку, а также полный набор mws-файлов с help-страницами, составляющими справочную базу Библиотеки, наряду с большим набором различного назначения примеров, позволяют достаточно легко адаптировать Библиотеку на базовые платформы, отличные от Windows-платформы. Более того, в виду наследования встроенными языками математических пакетов целого ряда общих черт, имеется хорошая возможность адаптации ряда процедур нашей Maple-библиотеки к программной среде других пакетов. В частности, целый ряд процедур Библиотеки достаточно легко был нами адаптирован к среде пакета Mathematica и некоторых других математических пакетов, тогда как предложенный нами метод “дисковых транзитов”, существенно расширяющий возможности программирования, эффективен не только для математических пакетов. При этом, следует иметь в виду, что исходные тексты программных средств, представленные в книге [103], и их представления в нашей Библиотеке (будучи функционально эквивалентными) могут в определенной степени различаться, что обусловлено широким использованием Библиотеки также и в учебных целях.

Наш и опыт наших коллег показывает, что использование Библиотеки в целом ряде случаев существенно расширяет возможности пакета Maple релизов 6 – 10 и последующих релизов, упрощая программирование различных прикладных задач в его среде. Данная Библиотека представит особый интерес прежде всего для тех, кто использует пакет Maple не только как высоко интеллектуальный калькулятор, но также и как среду программирования различных задач математического характера в своей профессиональной деятельности.

Библиотека в совокупности с главной Maple-библиотекой обладает полнотой в том отношении, что любое ее средство использует или средства главной библиотеки и/или средства самой Библиотеки. В этом плане она полностью самодостаточна. Ряд часто используемых процедур Библиотеки, ориентированных на массовое применение при программировании различных приложений, оптимизирован. Тогда как многие, обладая функциональной полнотой, на которую они и были ориентированы, между тем, в полной мере не оптимизированы, что предоставляет пользователю (прежде всего серьезно осваивающему программирование в Maple) достаточно широкое поле для его творчества как по оптимизиции процедуры, так и по созданию собственных аналогов, постоянно контролируя себя готовым, отлаженным и корректно функционирующим прообразом. Более того, используемые в процедурах полезные, эффективные (а в целом ряде случаев и нестандартные) приемы программирования позволяют более глубоко и за более короткий срок освоить программную среду пакета. Использование же во многих процедурах обработки особых и ошибочных ситуаций дает возможность акцентировать уже на ранней стадии внимание на таких важных компонентах создания программных средств, как их надежность, мобильность и ошибкоустойчивость. Наконец, работая с Библиотекой, пользователь не только имеет прекрасную возможность освоить многие из ее средств для своей текущей и последующей работы с пакетом, но и проникается концепцией эффективной организации своих собственных Maple-библиотек, содержащих средства, обеспечивающие его профессиональные интересы и потребности. Есть надежда, что и читатель книги найдет среди средств Библиотеки полезные для своего творчества. В предлагаемой книге рассматриваются принципы работы в программной среде Maple, основу которого составляет язык программирования Maple, что является непосредственным продолжением наших книг упомянутой серии [1-20,22-33,39,41-46,47,49,50,91,103], в которых обсуждаются ПС того же типа, что и рассматриваемое в настоящей книге. Придерживаясь выработанных методики и методологии подготовки указанных книг, наш подход делает основной акцент на изложении материала на основе развернутой апробации описываемой предметной области при решении задач как сугубо теоретических, так и прикладных. В предлагаемой книге представлены базовые сведения по языку программирования Maple – составляющему основу программной среды пакета, в которой пользователь имеет достаточно широкие возможности по разработке собственных Mapleприложений.

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

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

Двухуровневая лингвистическая поддержка пакета Maple обеспечивается такими языками программирования как С и Maple. В ряде публикаций встречается иная (не вполне обоснованная на наш взгляд) классификацию, когда выделялись три языка – реализации, входной и программирования. Суть же состоит в следующем. Действительно, ядро пакета Maple содержит набор высокоэффективных программ, написанных на С-языке. Более того, библиотека функций доступа к компонентам файловой системы компьютера непосредственно заимствована из соответствующей библиотеки С. По нашим оценкам доля программных средств пакета, написанных на С, не превышает 15%. Остальная масса программных средств пакета (функции, процедуры, модули), находящихся в различных библиотеках, написана на собственном Maple-языке. Уже ввиду сказанного весьма сомнительным выглядит утверждение, что С – язык реализации, а Maple – входной язык или язык программирования. Так как Maple-язык использован для реализации важнейших базовых средств пакета, то языками реализации являются и С, и Maple. При этом, с определенными допущениями можно говорить о входном Maple-языке и языке программирования Maple. В основе своей входной Maple-язык пакета базируется на встроенном языке программирования, являясь его подмножеством, обеспечивающим интерактивный режим работы с пакетом. Именно на входном Maple-языке в этом режиме пишутся и выполняются Maple-документы.

Входной язык ориентирован на решение математически ориентированных задач практически любой сложности в интерактивном режиме. Он обеспечивает диалог пользователя со своей вычислительной компонентой (вычислителем), принимая запросы пользователя на обработку данных с их последующей обработкой и возвратом результатов в символьном, числовом и/или графическом видах. Входной язык является языком интерпретирующего типа и идеологически подобен языкам этого типа. Он располагает большим числом математических и графических функций и процедур, и другими средствами из обширных библиотек пакета. Интерактивный характер языка позволяет легко реализовывать на его основе интуитивный принцип решения своих задач, при котором ход решения можно пошагово верифицировать, получая в конце концов требуемое решение. Уже введя первые предложения в текущий сеанс пакета, вы начинаете работать со входным Maple-языком. В настоящей же книге рассматривается наиболее полная лингвистическая компонента пакета – встроенный Maple-язык программирования (или просто Maple-язык). Вместе с тем, все примеры применения представленных в книге средств являются типичными предложениями входного Maple-языка пакета.

Среда программирования пакета обеспечивается встроенным Maple-языком, являющимся функционально полным процедурным языком программирования четвертого поколения (4GL). Он ориентирован, прежде всего, на эффективную реализацию как системных, так и задач пользователя из различных математически-ориентированных областей, расширение сферы приложений пакета, создание библиотек программных средств и т. д. Синтаксис Maple-языка наследует многие черты таких известных языков программирования как С, FORTRAN, BASIC и Pascal. Поэтому пользователю, в той либо иной мере знакомому как с этими языками, так и с программированием вообще, не составит особого труда освоить и Maple-язык.

Maple-язык имеет вполне традиционные стредства структурирования программ, включает в себя все команды и функции входного языка, ему доступны все специальные операторы и функции пакета. Многие из них являются достаточно серьезными программами, например, алгебраическое дифференцирование и интегрирование, задачи линейной алгебры, графика и анимация сложных трехмерных объектов и т. д. Являясь проблемно-ориентированным языком программирования, Maple-язык характеризуется довольно развитыми средствами для описания задач математического характера, возникающих в различных прикладных областях. В соответствии с языками данного класса структуры управляющей логики и данных Maple-языка в существенной мере отражают характеристику средств, прежде всего, именно для математических приложений. Наследуя многие черты С-языка, на котором написан компилятор интерпретирующего типа, Maple-язык позволяет обеспечивать как численные вычисления с любой точностью, так и символьные вычисления, поддерживая все основные операции традиционной математики. Однако, здесь следует привести одно весьма существенное пояснение.

Хорошо известно, что далеко не все задачи поддаются решению в аналитическом виде и приходится применять численные методы. Несмотря на то, что Maple-язык позволяет решать и такие задачи, его программы будут выполняться медленнее, чем созданные в среде языков компилирующего типа. Так что решение задач, требующих большого объема численных вычислений, в среде Maple может быть весьма неэффективно. Именно поэтому пакет предоставляет как средства перекодировки программ с Maple-языка на C, Java, FORTRAN, MatLab и VisualBasic, так и поддержку достаточно эффективного интерфейса с известным пакетом MatLab.

Средства Maple-языка позволяют пользователю работать в среде пакета в двух режимах: (1) на основе функциональных средств языка с использованием правил оформления и работы с Maple-документом предоставляется возможность на интерактивном уровне формировать и выполнять требуемый алгоритм вашей задачи без сколько-нибудь серьезного знания даже основ программирования, а подобно конструктору собирать из готовых функциональных компонент входного языка на основе его синтаксиса требуемый вам алгоритм, включая его выполнение, отображение результатов на экране (в обычном и/или графическом виде), в файле и в твердой копии, и (2) использовать всю мощь Mapleязыка для создания развитых систем конкретного назначения, так и средств, расширяющих собственно саму среду Maple, чьи возможности определяются только вашими собственными умением и навыками. При этом, первоначальное освоение языка не предполагает предварительного серьезного знакомства с основами программирования, хотя их знание и весьма предпочтительно.

Программирование в среде Maple-языка в большинстве случаев не требует какого-либо особого программистского навыка (хотя его наличие и весьма нелишне), т. к. в отличие от других языков универсального назначения и многих проблемно-ориентированных язык Maple включает большое число математически ориентированных функций и процедур, позволяя только одним вызовом решать достаточно сложные самостоятельные задачи, например: решать системы дифференциальных или алгебраических уравнений, находить минимакс выражения, вычислять производные и интегралы, выводить графики сложных функций и т.д. Интерактивность языка обеспечивает простоту его освоения и удобство редактирования и отладки прикладных Maple-документов и программ. Реальная же мощь Maple-языка обеспечивается не только его управляющими структурами и структурами данных, но и всем богатством его функциональных (встроенных, библиотечных, модульных) и прикладных (Maple-документов) сред-тв, созданных к настоящему времени пользователями из различных прикладных областей, прежде всего, математических. Важнейшим преимуществом Maple является открытость его архитектуры, что позволило в кратчайшие сроки создать широким кругом пользователей из многих областей науки, образования, техники и т.д. обширных наборов процедур и модулей, которые значительно расширили как его возможности, так и сферу приложений. К их числу можно с полным основанием отнести и представленную в [103] Библиотеку, содержащую более 730 средств, дополняющих средства пакета, устраняющих ряд его недоработок, расширяющих ряд его стандартных средств и повышающих уровень совместимости релизов пакета. Представленные в [103] средства используются достаточно широко как при работе с пакетом Maple в интерактивном режиме, так и при программировании различных задач в его среде. Они представляют несомненный интерес при программировании различных задач в среде Maple, как упрощая собственно сам процесс программирования, так и делая его более прозрачным с формальной точки зрения.

Таким образом, пакет Maple – не просто высоко интеллектуальный калькулятор, способный аналитически решать многие задачи, а легко обучаемая система, вклад в обучение которой вносят как сами разработчики пакета, так и его многочисленные пользователи. Очевидно, как бы ни была совершенна система, всегда найдется много специальных задач, которые оказались за пределами интересов ее разработчиков. Освоив относительно простой, но весьма эффективный Maple-язык, пользователь может изменять уже существующие процедуры либо расширять пакет новыми, ориентированными на решение нужных ему задач. Эти процедуры можно включать в одну или несколько пользовательских библиотек, снабдить справочной базой, логически сцепить с главной библиотекой пакета, так что их средства на логическом уровне будут неотличимы от стандартных средств пакета. Именно таким образом и организована наша Библиотека [103,108,109]. И последнее, Maple-язык – наименее подверженная изменениям компонента пакета, поэтому ее освоение позволит вам весьма существенно пролонгировать эффективное использование пакета для решения тех задач, которые прямо не поддерживаются пакетом.

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

В настоящей книге рассматриваются основы Maple-языка программирования в предположении, что читатель в определенной мере имеет представление о работе в Windowsсреде и с самим пакетом в режиме его главного меню (GUI) в пределах, например, книг [8-14,29-33,39,42-46,54-62,103] и подобных им изданий. Представленные ниже сведения по Maple-языку в значительной мере обеспечат вас тем необходимым минимумом знаний, который позволит знакомиться со средствами главной библиотеки пакета и нашей Библиотеки [103]. Данная работа, в свою очередь, даст вам определенный навык программирования, а также обеспечит вас набором полезных приемов и методов программирования (включая и нестандартные) в среде Maple-языка наряду с практически полезными средствами, упрошающими решение многих прикладных задач, составляющих ваши приложения. Кратко охарактеризуем содержание предлагаемой книги.

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

Вторая глава представляет базовые управляющие структуры Maple-языка: ветвления (ifпредложение), организации циклических вычислений (while_do-предложение), а также специальные типы циклических управляющих структур Maple-языка.

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

Четвертая глава рассматривает вопросы организация программных модулей Maple-языка и сохранения процедур и программных модулей в файлах входного и внутреннего форматов.

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

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

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

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

Подобно другим ПС, ориентированным на решение задач математического характера, пакет Maple располагает достаточно развитыми средствами, обеспечивающими решение широкого круга задач математического анализа и линейной алгебры. Эти две дисциплины представляют собой основную базовую компоненту современного математического образования естественно-научных специальностей и особых пояснений не требуют. Вместе с тем, следует сразу же отметить, что в дальнейшем вопросы решения задач математического анализа, линейной алгебры и других математически-ориентированных дисциплин в среде Maple (учитывая специфику настоящей книги) не рассматриваются. В принципе, сложности при освоении средств данной группы особой возникать не должно и они достаточно хорошо изложены в многочисленной литературе как зарубежной, так и отечественной [8-14,54-62]. В книгах [41-43,103] мы представили средства, функционирующие в среде пакета релизов 6–10 и ориентированные, прежде всего, на решение задач математического анализа. Там же представлены средства, расширяющие возможности пакета при решении задач линейной алгебры. Данные средства классифицируются относительно стандартных средств двух основных пакетных модулей, ориентированных, прежде всего, на задачи линейной алгебры, а именно: традиционный Maple-модуль linalg и имплантированный модуль LinearAlgebra фирмы NAG. Представлены дополнительные средства, обеспечивающие решение ряда массовых задач линейной алгебры.

Более того, не рассматриваются детально здесь и такие важные средства пакета как графические и обеспечения доступа к файлам данных. Мотивировано данное решение тем, что эти средства довольно хорошо изложены в наших предыдущих книгах, книгах других авторов и в справочной системе по пакету. В частности, в книге [12] достаточно детально рассмотрена система ввода/вывода пакета, которая не претерпела каких-либо существенных изменений вот уже на протяжении 6 релизов. Основной акцент здесь сделан на тех аспектах средств доступа, которые не нашли отражения в имеющихся на сегодня изданиях по Maple-языку, включая и фирменную литературу, стандартно поставляемую с пакетом. В целом же система ввода/вывода пакета может быть охарактеризована следующим образом.

Будучи языком программирования в среде пакета компьютерной алгебры, ориентированного, прежде всего, на задачи алгебраических вычислений, Maple-язык располагает относительно ограниченными возможностями при работе с данными, которые расположены во внешней памяти компьютера. Более того, в этом отношении Maple-язык существенно уступает таким традиционным языкам программирования как C, Cobol, PL/1, FORTRAN, Pascal, Ada, Basic и т. д. В то же самое время Maple-язык, ориентированный, прежде всего, на решение задач математического характера, предоставляет тот набор средств для доступа к файлам данных, которые могут вполне удовлетворить довольно широкую аудиторию пользователей пакета и его физических и математических приложений. В наших книгах [41-42,103] представлен целый ряд дополнительных средств доступа к файлам данных, существенно расширяющих пакет в данном направлении. Многие из них упрощают программирование целого ряда задач, имеющих дело с доступом к файлам данных различной организации, содержания и назначения.

Со всей определенностью можно констатировать, что новые пакетные модули FileTools и LibraryTools были вдохновлены рядом наших книг по Maple-тематике [29-33,39,42-46], с которыми разработчики пакета были ознакомлены. Однако, наш набор подобных процедур является значительно более представительным и они сосредоточены на более широком практическом использовании при решении задач, имеющих дело с обработкой файлов данных. Более того, нам не известно более обстоятельное рассмотрение системы доступа к файлам, обеспечиваемой пакетом, чем в наших предыдущих книгах [8-14, 29-33,39,41-43,45,46,103]. Именно в этом отношении они рекомендуются читателю, имеющему дело с подобными задачами.

В определенной мере вышесказанное можно отнести и к графическим средствам пакета. Так, в вышеуказанных книгах представлены средства, расширяющие стандартный набор графического инструментария пакета Maple релизов 6 – 10. Предлагаемые средства являются довольно полезными процедурами, представляющими определенный прикладной интерес, что подтверждает эффективность их использования при решении целого ряда прикладных задач с использованием графических объектов. В частности, на сегодня, стандартные средства пакета, ориентированные на работу с анимируемыми графическими объектами, имеют целый ряд ограничений на динамическое обновление их характеристик. Между тем, многие задачи, имеющие дело с графическими анимируемыми объектами, предполагают возможность динамического обновления их характеристик. Представлен ряд средств в этом направлении. Заинтересованный читатель отсылается к книгам [8-14,32,78,84,86,88,55,59-62], а также к [91] с адресом сайта (Локальная копия сайта), с которого можно бесплатно загружать некоторые из наших предыдущих книг по данной тематике.

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

Читатель, имеющий опыт программирования в среде Maple, может вполне (быть может, за редким исключением) безболезненно опустить данный материал. Тогда как начинающий на этом поприще получит необходимый минимум сведений по Maple-языку, который позволит значительно проще совершенствоваться в этом направлении. Для более глубокого ознакомления с Maple-языком нами приведены полезные ссылки как на отечественные, так и на зарубежные издания. Более того, читатель, заинтересованный в освоении программной среды пакета Maple, может найти немало полезной информации как в справочной системе по пакету, литературе, поставляемой с пакетом, так и на ведущих Web-серверах и форумах, посвященных Maple-тематике. В век почти массовой компьютеризации и интернетизации лишь ленивый может аппелировать к недостатку нужной информации по какому бы то ни было разделу современного знания.

По ходу настоящей книги будет приведено немало ссылок на наши издания, что следует совершенно непредвзято трактовать и вот почему. Прежде всего, в настояшей книге рассматриваются вопросы программирования в среде пакета Maple, которое является основой разработки в его среде эффективного программного обеспечения, ориентированного на те или иные приложения. В отечественной же литературе других изданий, рассматривающих столь скрупулезно данную проблематику (как, впрочем, и в англоязычной), на мой взгляд, просто нет (и это не только мое субъективное мнение). Наконец, вполне это уместно и в том потребительском контексте, что основная масса цитируемых наших изданий по Maple-тематике может быть совершенно бесплатно получена с указанного в [91] Internet-адреса Гродненского университета. Конечно, там представлены издания, ориентированные на Maple 5 – 7, однако ввиду полной приемственности по основным аспектам программной среды пакета они (с некоторыми оговорками) вполне пригодны и для последующих релизов пакета.

Заключение представляет краткий экскурс в историю создания нашей Maple-библиотеки, которая будет неоднократно цитироваться в настоящей книге. Здесь лишь хочу предупредить, что во многом она создавалась еще в Maple релизов 5–7, когда нас не совсем устраивали как целый ряд базовых средств пакета, так и возможности пакета. Поэтому создавались средства как заполняющие подобный ваккуум, так и устраняющие замеченные недостатки пакета. С появлением новых релизов базовые средства пакета и его средства в целом расширялись и улучшались, поэтому ряд средств библиотеки могут, на первый взгляд, показаться устаревшими (obsolete), однако они все еще представляют интерес с учебной точки зрения, предлагая немало эффективных и полезных приемов программирования, не утративших своей актуальности и поныне. Многие же из библиотечных средств и на сегодня не имеют аналогов. В последние пару лет Maple-тематике в ее прямом смысле мы уделяли относительно немного внимания, используя, между тем, пакет в целом ряде физико-математических и инженерных приложений, а также в преподавании математических курсов для докторантов, различных курсов и мастер-классов по Maple. В будущем данная тематика не планируется в числе наших активных интересов, поэтому наши публикации в этом направлении будут носить в значительной мере спорадический характер. Вот и данное издание, посвященное вопросам сугубо программирования в Maple, также в значительной мере специально не планировалось, поэтому оно не было подвержено тщательному редактированию. Однако смеем надеяться, что и в таком виде оно представит определенный интерес как для начинающих, так и даже имеющих определенный опыт программирования в среде Maple, да и не только.

Еще на одном важном моменте следует акцентировать внимание. Разработка Maple-приложений базируется на программной среде пакета. Здесь можно выделить ряд уровней разработки, которые представляются нам под следующим углом, а именно:

(1) Maple-документы, решающие отдельные прикладные задачи (типичным примером такого подхода может служить набор Maple-документов, решающих типичные инженерно-физические задачи методом конечных элементов [11,13,14,43,110]);

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

(3) библиотеки процедур и модулей, организованные аналогично главной библиотеке пакета и решающие достаточно широкий круг как задач из различных приложений, так и системных, расширяющих функциональную среду самого пакета (типичным примером служит наша Библиотека [41,103,108,109]).

Естественно, представленная классификация в значительной степени субъективна, однако при отсутствии иной и она может служить в качестве отправной точки. Средства первого уровня представляют собой законченные Maple-документы, т.е. {mws, mw}-файлы, решающие конкретные прикладные залачи из различных приложений. Они могут содержать описательную часть, постановку задачи, алгоритм, описанный входным Mapleязыком, результаты выполнения документа и другую необходимую информацию. Как правило, сложная задача либо комплекс задач реализуются набором {mws, mw}-файлов, сохраняемых в отдельном каталоге и доступных для выполнения путем загрузки в среду Maple соответствующего релиза либо поочередно, либо в требуемом порядке. Для создания таких документов вполне можно обходиться лишь входным Maple-языком, а не полным набором средств, предоставляемых его расширением – встроенным языком программирования. В целом, данный уровень допускает и диспетчирование документов, например, соедующим образом.

У традиционного Maple-документа после его отладки удаляются все Output-параграфы и он сохраняется в текстовом файле в рамках только своих Input-параграфов. Создается Maple-документ, обеспечивающий загрузку в нужном порядке в текущий сеанс по readпредложению созданные описанным образом txt-файлы, обеспечивая необходимое диспетчирование документов.

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

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

Литература содержит интересные и полезные как зарубежные, так и отечественные источники по Maple-тематике, которые являются вполне доступными. При этом многие из наших изданий (точнее их авторские оригинал-макеты) можно бесплатно получать с указанного в [91] Internet-адреса Гродненского государственного университета им. Я. Купалы. Там же можно найти и массу полезных примеров по Maple-тематике.

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

- ПС – программное средство;

- ПО – программное обеспечение;

- ПК – персональный компьютер;

- альтернативные элементы разделяются символом “|“ и заключаются в фигур- ные скобки, например, {A|B} – A или B;

- смысл конструкции указывается в угловых скобках “< ... >“;

- под выражением “по умолчанию” понимается значение той или иной характе- ристики операционной среды или пакета, которое используется, если пользова- телем не определено для нее иное значение;

- под «регистро-зависимым (независимым)» режимом будем понимать такой режим поиска, сравнения и т.д. символов и строк, когда принимаются (не принимаются) в расчет различия между одинаковыми буквами верхнего и нижнего регистра кла- виатуры. В частности, все идентификаторы в программной среде Maple регист- ро-зависимы;

- понятия “имя УВВ, имя файла, каталог, подкаталог, цепочка каталогов, путь” соот- ветствуют полностью соглашениям MS DOS; при кодировании пути к файлу в

качестве разделителя используется, как правило, сдвоенный обратный слэш (\\);

- СФ - спецификатор файла, определяющий полный путь к нему либо имя;

- СБО (Сlipboard) – системный буфер обмена;

- ГМП (GUI) - главное меню пакета; содержит группы функций его оболочки;

- hhh-файл - файл, имеющий “hhh” в качестве расширения его имени; - под Input-параграфом в дальнейшем понимается вводимая в интерактивном ре- жиме в текущий сеанс информация, слева идентифицируемая символом ввода «>». По умолчанию, ввод оформляется красным цветом. Тогда как под Output- параграфом понимается результат выполнения предшествующего ему Input-па- раграфа (выражения, тексты процедур и модулей, графические объекты и т.д.). Сле- дующий простой пример поясняет вышесказанное:

> A, V:= 2, 12: assign('G' = Int(1/x*sin(x)*cos(x), x)), G = value(G); plot(rhs(%), x = 4 .. V, thickness=A, color=green, axesfont=[TIMES, BOLD, V], labelfont=[TIMES, BOLD, V]);

⌠

В дальнейшем ради удобства и компактности там, где это возможно, блок из 2-х параграфов {Input, Output} будем представлять в строчном формате, а именно: > Input-параграф; ⇒ Output-параграф

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

www.aladjev.newmail.ru, www.aladjev.narod.ru, www.aladjev-maple.narod.ru

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

Гродно – Таллинн, февраль, 2007

Глава 1. Базовые сведения по Maple-языку пакета

Пакет Maple способен решать большое число, прежде всего, математически ориентированных задач вообще без программирования в общепринятом смысле. Вполне можно ограничиться лишь описанием алгоритма решения своей задачи, разбитого на отдельные последовательные этапы, для которых Maple имеет уже готовые решения. При этом, Maple располагает довольно большим набором процедур и функций, непосредственно решающих совсем не тривиальные задачи как то интегрирование, дифференциальные уравнения и др. О многочисленных приложениях Maple в виде т.н. пакетов и говорить не приходится. Тем не менее, это вовсе не означает, что Maple не предполагает программирования. Имея собственный достаточно развитый язык программирования (в дальнейшем просто Maple-язык), пакет позволяет программировать в своей среде самые разнообразные задачи из различных приложений. Обсуждение данного аспекта нашло отражение в нашей книге [103], а именно о дилетантском взгляде на вопрос программирования в Maple, да, впрочем, и в ряде других математических пакетов.

В среде пакета можно работать в двух основных режимах: интерактивном и автоматическом (программном). Интерактивный режим аналогичен работе с калькулятором, пусть и весьма высоко интеллектуальным – в Input-параграфе вводится требуемое Maple-выражение и в следующем за ним Output-параграфе получаем результат его вычисления. Так шаг за шагом можно решать в среде пакета достаточно сложные математические задачи, в процессе работы формируя текущий документ (ТД). Для такого режима требуется относительно небольшой объем знаний о самом пакете, а именно:

* знание общей структуры ТД и синтаксиса кодирования выражений;

* знание синтаксиса используемых функциональных конструкций;

* общие правила выполнения, редактирования и сохранения текущего документа.

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

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

Однако для более сложной работы (выполняющейся, как правило, в программном режиме) требуется знание встроенного Maple-языка программирования, который позволяет использовать всю вычислительную мощь пакета и создавать сложные ПС, не только решающие задачи пользователя, но и расширяющие средства самого пакета. Примеры такого типа представлены как в нашей книге [103], так и в настоящей книге. Именно поэтому, далее представим основные элементы программирования в среде пакета Maple.

Для лингвистического обеспечения решения задач пакет снабжен развитым встроенным проблемно-ориентированным Maple-языком, поддерживающим интерактивный режим. Являясь проблеммно-ориентированным языком программирования, Maple-язык характеризуется довольно развитыми средствами для описания задач математического характера, возникающих в различных прикладных областях. В соответствии с языками этого класса структуры управляющей логики и данных Maple-языка в существенной мере отражают специфику средств именно для математических приложений. Особую компоненту языка составляет его функциональная составляющая, поддерживаемая развитой библиотекой функций, покрывающих большую часть математических приложений. Наследуя многие черты С-языка, на котором был написан компилятор интерпретирующего типа, Maple-язык позволяет обеспечивать как численные вычисления с любой точностью, так и символьную обработку выражений и данных, поддерживая все основные операции традиционной математики [8-14].

Средства Maple-языка позволяют пользователю работать в среде пакета в двух режимах: (1) на основе функциональных средств языка с использованием правил оформления и работы с Maple-документом предоставляется возможность на интерактивном уровне формировать и выполнять требуемый алгоритм прикладной задачи без сколько-нибудь существенного знания даже основ программирования, а подобно конструктору собирать из готовых функциональных компонент языка на основе его синтаксиса требуемый вам алгоритм, включая его выполнение, отображение результатов на экране (в обычном или графическом виде), в файле и в твердой копии, и (2) использовать всю мощь языка как для создания развитых систем конкретного назначения, так и средств, расширяющих собственно саму среду пакета, возможности которых определяются только вашими собственными умением и навыками. При этом, первоначальное освоение языка не предполагает предварительного серьезного знакомства с основами программирования, хотя знание их и весьма предпочтительно. Тут же уместно отметить, что значительная часть функциональных средств самого пакета написана и скомпилирована именно на Maple-языке, позволившим создать довольно эффективные относительно основных ресурсов ЭВМ загрузочные модули. Анализ данных средств является весьма неплохим подспорьем при серьезном освоении Maple-языка. Наряду с этим, в архиве [109] представлены исходные тексты процедур и программных модулей нашей Библиотеки [41], которые также могут служить в качестве неплохого иллюстративного материала для осваивающих программную среду пакета.

В настоящей главе рассматриваются базовые элементы Maple-языка в предположении, что читатель в определенной мере имеет представление о работе в Windows-среде и с самим пакетом в режиме его графического меню (GUI) в пределах главы 3 [12] либо, например, книг [29-33,45,46,54-62,78-89,103,108,111-130] и подобных им изданий.

1.1. Базовые элементы Maple-языка пакета

Определение Maple-языка можно условно разбить на четыре базовые составляющие, а именно: алфавит, лексемы, синтаксис и семантику. Именно две последние составляющие и определяют суть того или иного языка. Синтаксис составляют правила образования корректных предложений из слов языка, которые должны строго соблюдаться. В случае обнаружения на входе Maple-предложения с синтаксической ошибкой выводится диагностическое сообщение, сопровождаемое “^”-указателем на место возможной ошибки или установкой в место ошибки |-курсора, как это иллюстрирует следующий фрагмент:

При этом следует иметь в виду два обстоятельства: (1) идентифицируется только первая встреченная ошибка и (2) при наличии синтаксических ошибок (например, несогласования открывающих и закрывающих скобок) в сложных выражениях язык может затрудняться с точной их диагностикой, идентифицируя ошибочную ситуацию сообщением вида “ `;` unexpected”, носящим в целом ряде случаев весьма приблизительный характер. Mapleязык производит синтаксический контроль не только на входе конструкций в интерактивном режиме работы, но и в момент считывания их из файлов. В последнем случае синтаксическая ошибка инициирует вывод соответствующего диагностического сообщения указанного выше вида с указанием номера первой считанной строки, содержащей ошибку, и идентификацией спецификатора файла, как это иллюстрирует последний пример фрагмента. Ниже вопросы синтаксического анализа Maple-конструкций будут рассмотрены более детально, прежде всего, при рассмотрении parse-функции пакета.

В отличие от синтаксиса, определяющего правила составления корректных языковых конструкций, семантика языка определяет алгоритмы их обработки, т.е. определяет их понятийное назначение с точки зрения самого языка. Например, результатом обработки конструкции вида “W:= 57*sin(19.99);” является присвоение W-переменной результата произведения целого числа “57” и значения sin-функции в точке “19.99” ее вызова. При этом, определяется как собственно результат, так и его тип. В связи со сказанным наряду с синтаксическими, как правило, распознаваемыми языком, могут возникать и семантические ошибки, которые язык не распознает, если они при этом, не инициируют, в свою очередь, ошибок выполнения. Типичным примером семантических ошибок является конструкция вида “A/B*C”, трактуемая языком как “(A*C)/B”, а не как “A/(B*C)” на первый взгляд. Как правило, семантические ошибки выявляются на стадии выполнения Maple-программы или вычисления отдельных Maple-выражений и данная процедура относится к этапу отладки программ и процедур, рассматриваемому несколько ниже.

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

♦ заглавные и прописные буквы латинского алфавита (A .. ÷Z; a .. ÷z; 52);

♦ десятичные цифры (0 .. 9; 10);

♦ специальные символы (` ! @ # $ % ^ & * ( ) _ + { } : “ < > ? | - = [ ] ; ‘ , . / \; 32); ♦ заглавные и прописные буквы русского алфавита (кириллицы: A .. Я; a .. я; 64).

Синтаксис Maple-языка объединяет символы входного алфавита в лексемы, состоящие из ключевых (зарезервированных) слов, операторов, строк, натуральных чисел и знаков пунктуации. Рассмотрим несколько детальнее каждую из составляющих. В качестве ключевых Maple-язык использует слова, представленные в следующей табл. 1.

Таблица 1

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

> local:= 64;

Error, reserved word `local` unexpected

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

Операторы языка относятся к трем типам: бинарные, унарные и нульарные. Допускаемые языком унарные операторы представлены в следующей табл. 2.

Таблица 2

Унарные операторы (+, -, not) и десятичная точка (.) имеют вполне прозрачный смысл и особых пояснений не требуют. Здесь мы кратко остановимся на операторе метки (%); при этом понятие метки в Maple-языке существенно иное, чем для традиционных языков программирования. Унарный оператор метки кодируется в виде %<целое> и служит для представления общих подвыражений большого выражения в целях более наглядного представления второго. Данный оператор используется Maple-языком для вывода выражений на экран и на принтер в удобном виде. После возвращения языком представленного в терминах %-оператора выражения к переменным %<целое> можно обращаться как к обычным определенным переменным. Для возможности использования представления выражений в терминах %-оператора используются две опции interface-переменной оболочки пакета: labelling и labelwidth, определяющих соответственно допустимость такого представления и длину меченных подвыражений. При этом, данная возможность допустима не для всех форматов Output-параграфа текущего документа.

Допустимые языком базовые бинарные операторы представлены в следующей табл. 3.

Таблица 3

С большинством из приведенных в табл. 3 унарных операторов читатель должен быть хорошо знаком, тогда как такие как (:=, $, @, @@, ..) в определенной мере специфичны для математически ориентированных языков и будут рассмотрены ниже. По остальным же пояснения будут даваться ниже по мере такой необходимости.

Наконец, три нульарных оператора %, %% и %%% (один, два и три знака процентов) представляют специальные идентификаторы Maple-языка, принимающие в качестве значений результат вычисления соответственно последнего, предпоследнего и предпредпоследнего предложения. Следующий фрагмент иллюстрирует применение нульарных операторов:

> AG:= 59: AV:= 64: AS:= 39: (%%+3*%+%%%-2); ⇒ 238

> P:=proc() args; nargs; %, %% end proc: P(59, 64, 39, 17, 10, 44); ⇒ 6, 59, 64, 39, 17, 10, 44

Как правило, нульарные операторы используются в интерактивном режиме работы с пакетом и выступают на уровне обычных переменных, позволяя обращаться к результатам предыдущих вычислений на глубину до трех. Однако использование их вполне допустимо и в теле процедур, где они выступают на уровне локальных переменных, как это иллюстрирует второй пример фрагмента. Вопросы организации процедур рассматриваются ниже. Наряду с возможностью использования {%|%%|%%%}-конструкции для доступа к результатам предыдущих вычислений в текущем сеансе работы языком предоставляется history-механизм обращения к любому полученному в рамках его истории вычислению. Детально данный механизм рассмотрен в нашей книге [12]. В частности, там же представлен и анализ данного механизма, говорящий о недостаточно продуманной и реализованной системе, обеспечива-ющей history-механизм; в целом весьма полезного средства, но при наличии существенно более широких возможностей, подобных, например, пакету Mathematica [6,7], где подобный механизм представляется нам намного более развитым.

Приоритетность операторов Maple-языка в порядке убывания определяется как:

|| :- :: % & ! {^, @@} { ., *, &*, /, @, intersect} {+, -, union, minus} mod subset

.. {<, <=, >, >=, =, <>, in} $ not and or xor implies -> , assuming :=

В качестве строк Maple-язык рассматривает любые последовательности символов, кодируемые в верхних двойных кавычках ("), например: "Академия Ноосферы". При этом, составлять строку могут любые допустимые синтаксисом языка символы. При необходимости поместить в строку верхнюю двойную кавычку ее следует дублировать либо вводить комбинацией вида (\"). Это же относится и к ряду других символов, вводимых посредством обратного слэша (\), как это иллюстрирует следующий весьма простой фрагмент:

> `Строка`:= "Международная Академия Ноосферы"; Строка:= "Международная Академия Ноосферы"

> `Строка 1`:= "Международная\nАкадемия\nНоосферы";

Строка 1 := "Международная

Академия

Ноосферы"

> `Строка 2`:= "Internatio\nal Academy of Noosphere"; Строка 2 := "Internatio nal Academy of Noosphere"

> `Строка 3`:= "Российская Эколо"гическая Академия";

Error, missing operator or `;`

Однако, как иллюстрируют примеры фрагмента, если наличие в строке одинарной двойной кавычки (помимо ограничивающих) вызывает синтаксическую ошибку, то для случая обратного слэша в общем случае могут возникать семантические ошибки. Максимальная длина строки зависит от используемой платформы: для 32-битных ЭВМ - 524271 символов, а для 64-битных - 34359738335 символов. О средствах работы со строчными структурами детальнее речь будет идти несколько ниже.

В качестве символов Maple-язык рассматривает любые последовательности символов, в общем кодируемые в верхних обратных кавычках (`), например: `Академия Ноосферы 64`. При этом, составлять символ могут любые допустимые синтаксисом языка символы. При необходимости поместить в символ верхнюю обратную кавычку ее следует дублировать либо вводить комбинацией вида (\`). Это же относится и к ряду других символов, вводимых посредством обратного слэша (\), как это иллюстрирует фрагмент:

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

> "Данные":= 2006;

Error, invalid left hand side of assignment

> Данные:= 2006: `Результат`:=350: Данные, Результат;

2006, 350

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

В качестве натурального целого язык рассматривает любую последовательность из одной или более десятичных цифр, при этом все ведущие нули игнорируются, т.е. 005742 рассматривается как 5742. Длина таких чисел зависит от используемой пакетом платформы и на большинстве 32-битных ЭВМ составляет порядка 524280 десятичных цифр, тогда как на 64-битных она достигает уже 38654705646 цифры. В качестве целого рассматривается натуральное целое со знаком или без. Для работы с арифметикой целых чисел язык располагает достаточно развитыми средствами, рассматриваемыми ниже.

Наконец, знаки пунктуации Maple-языка представлены в следующей табл. 4.

Таблица 4

Представим использование Maple-языком указанных в табл. 4 знаков пунктуации:

: и ; - служат для идентификации конца предложений Maple-языка; различия между ними обсуждаются ниже;

( ) - для группировки термов в выражениях, а также формальных или фактических аргументов при определениях или вызовах функций/процедур;

<> - для определенной пользователем группировки выражений;

{} - для определения структур данных типа множество;

[] - для определения структур данных типа список, а также для образования индек- сированных переменных и оператора выбора элемента из индексированных вы- ражений;

` ' , - соответственно для определения идентификаторов, невычисляемых выражений и структур типа последовательность; при этом, следует четко различать при коди- ровании конструкций Maple-языка символы верхней обратной кавычки (96) и апо- строфа (39), в скобках даны их десятичные коды по внутренней кодовой таблице; " - верхние двойные кавычки служат для определения строчных структур данных.

Для разделения лексемов синтаксис языка допускает использование как знаков пунктуации, так и пробелов, понимаемых в расширенном смысле, т.е. в качестве пробелов допускается ис-ользование символов: собственно пробела (space), табуляции (tab), перевода строки и возврата каретки. При этом, сами символы пробела не могут входить в состав лексемов, являясь их разделителями. Между тем, space-символ может входить в состав строк и символов, образованных двойными или одинарными верхними кавычками. Использование же его в составе лексема, как правило, инициирует ошибочную ситуацию, например: > AGN: = sqrt(x^2 + y^2 + z^2 + 19.47);

Error, `=` unexpected

Под программной строкой в Maple-языке понимается строка символов, завершающаяся символами перевода строки и возврата каретки (16-ричные коды 0D0A); при этом, сами эти символы строке не принадлежат. Пустые программные строки образуются простым нажатием Enter-клавиши. Завершение программной строки по Enter-клавише в интерактивном режиме вызывает немедленное вычисление всех содержащихся в ней выражений и предложений языка. Если в программной строке содержится #-символ, то язык рассматривает всю последующую за ним информацию в качестве комментария и обработки ее не производит. Этот прием можно использовать для комментирования текстов Mapleпрограмм, тогда как в интерактивном режиме особого смысла он не имеет. Вывод длинных строк производится в несколько строк экрана, идентифицируя символом обратного слэша (\) продолжение строки. При этом символ обратного слэша несет более широкую смысловую нагрузку, а именно: наряду с функцией продолжения он может выступать в качестве пассивного оператора и средства ввода управляющих символов.

В первом качестве он используется, как правило, для разбиения на группы строчных структур или цифровых последовательностей в целях более удобного их восприятия. Тогда как во втором случае он позволяет вводить управляющие символы, производящие те или иные действия. В этом случае кодируется конструкция следующего вида: ”\<управляющий символ>”, где управляющий символ является одним из следующих восьми {a, b, e, f, n, r, t, v}; например, по конструкции “\n” производится перевод строки, а по “\a” – звонок, с другими детально можно ознакомиться по книге [10] либо по Help-системе пакета посредством предложения вида: > ?backslash. Следующий фрагмент иллюстрирует использование символа обратного слэша в указанных выше контекстах:

Употребление обратного слэша без следующего за ним одного из указанных управляющих символов в середине лексема приводит к его игнорированию, т.е. он выступает в качестве пустого оператора. Для действительного ввода в строку обратного слэша его нужно кодировать сдвоенным. При этом, следует иметь в виду, что в случае кодирования спецификаторов файлов в функциях доступа в качестве разделителей подкаталогов можно использовать сдвоенные обратные слэши (\\) или одинарные прямые слэши (/), в противном случае возможно возникновение семантических ошибок. По конструкции вида kernelopts(dirsep) возвращается стандартный разделитель подкаталогов, принимаемый по умолчанию, однако его переопределение невозможно.

После успешной загрузки пакета Maple производится выход на его главное окно, структура и назначение компонент которого детально рассмотрены, например, в [9-14]. В области текущего документа в первой строке устанавливается >-метка ввода, идентифицирующая запрос на ввод информации, как правило, завершающийся {;|:}-разделителем с последующим нажатием Enter-клавиши либо активацией !-кнопки 4-й строки главного окна. Результатом данной процедуры является передача пакету программной строки, содержащей отдельное Maple-выражение, вызов функции либо несколько предложений языка. Под Maple-программой (документом) понимается последовательность предложений языка, описывающая алгоритм решаемой задачи, и выполняемая, если не указано противного, в естественном порядке следования своих предложений.

В интерактивном режиме ввод программной строки производится непосредственно за >-меткой ввода (Input-параграф текущего документа) и завершается по клавише Enter, инициирующей синтаксический контроль введенной информации с последующим вычислением (если не обнаружено синтаксических ошибок) всех входящих в строку Maple-предложений. В дальнейшем мы ради удобства представления иллюстративных примеров программную строку и результат ее вычисления будем иногда представлять в следующем достаточно естественном формате:

> Maple-предложение {:|;} ⇒ Результат вычисления

При этом, в зависимости от завершения Maple-предложения {;|:}-разделителем результат его вычисления соответственно {выводится|не выводится} в текущий документ, т. е. {формируется|не формируется} Output-параграф. Однако следует иметь в виду, что «не формируется» вовсе не означает «не возвращается» – результат выполнения Input-параграфа всегда возвращается и его можно получать, например, по нульарному %-оператору, как это иллюстрирует следующий весьма простой фрагмент:

> Tallinn:= 2006; ⇒ Tallinn := 2006

> %; ⇒ 2006

> Tallinn:= Grodno: %; ⇒ Grodno

Однако здесь следует иметь в виду, что может возвращаться и NULL-значение, т.е ничего. В этом случае %-оператор возвращает последний результат, отличный от NULL, как это иллюстрирует следующий простой пример:

> x:= 5: assign('y' = 64); assign('z' = 59); assign('s' = 39); %; ⇒ 5

Использование (:)-разделителя служит, главным образом, для того, чтобы избавиться в Maple-документе от ненужного вывода промежуточной и несущественной информации. Структурная организация Maple-документов достаточно детально была рассмотрена в [9-14,78-89]. Здесь мы лишь отметим особые типы программных строк, начинающихся с двух специальных управляющих {?, !}-символов Maple-языка пакета.

Использование в самом начале программной строки в качестве первого, отличного от пробела, ?-символа рассматривается Maple-языком как инструкция о том, что следующая за ним информация - фактические аргументы (последовательность которых разделяется запятой “,” или прямым слэшем “/”) для help-процедуры, обеспечивающей вывод справочной информации по указанным аргументами средствам пакета. Например, по конструкции формата “> ?integer“ выводится справка integer-раздела Help-системы пакета.

Использование в самом начале программной строки в качестве первого, отличного от пробела, !-символа рассматривается Maple-языком как инструкция о том, что следующая за ним информация предназначена в качестве команды для ведущей ЭВМ. Однако данная возможность поддерживается не всеми операционными платформами, например, для Windows-платформы в данном случае идентифицируется синтаксическая ошибка. Рассмотрев базовые элементы Maple-языка, переходим к более сложным его конструкциям.

1.2. Идентификаторы, предложения присвоения и выделения Maple-языка

Основной базовой единицей языка является предложение, представляющее собой любое допустимое Maple-выражение, завершающееся {;|:}-разделителем. Более того, не нарушая синтаксиса Maple-языка, под предложением будем понимать любую допустимую Maple-конструкцию, завершающуюся {;|:}-разделителем; при этом, предложение может завершаться и по Enter-клавише (символы перевод строки и возврат каретки), если оно содержит единственное выражение. В ряде случаев допустимо использование в качестве разделителя Maple-предложений даже запятой, если они находятся внутри программной строки, что позволяет выводить результаты вычислений в строчном (разделенном запятой) формате. Однако это требует весьма внимательного подхода, как к нетипичному приему. Следующий фрагмент иллюстрирует все перечисленные способы кодирования Maple-предложений:

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

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

Идентификаторы . В терминологии пакета под символами (symbol) понимаются как собственно цепочки символов, так и идентификаторы, удовлетворяющие соглашениям пакета, т.е. имена для всех конструкций Maple-языка пакета. Идентификаторы служат для установления связей между различными компонентами вычислительного процесса как логических, так и информационных, а также для образования выражений и других вычислительных конструкций. В качестве идентификатора в Maple-языке выступает цепочка из не более, чем 524271 символов для 32-битной платформы и не более 34359738335 символов для 64-битной платформы, начинающаяся с буквы либо символа подчеркивания (_). Идентификаторы регистро-зависимы, т.е. одинаковые буквы на верхнем и нижнем регистрах клавиатуры полагаются различными. Данное обстоятельство может служить, на первых порах, источником синтаксических и семантических ошибок, ибо в большинстве современных ПС идентификаторы, как правило, регистро-независимы. В качестве примеров простых идентификаторов можно привести следующие:

AVZ, Agn, Vs_A_K, Ar_10, KrV, Tall_Est, Salcombe_Eesti_Ltd_99, Vasco_97

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

> `ТРГ=TRG_9`:= 64: `Значение 1`:= 1942: evalf(`Значение 1`/`ТРГ=TRG_9`, 12);

30.3437500000

> Таллинн:= 56: Гродно:= 84: Вильнюс:= 100: Таллинн + Гродно + Вильнюс;

240

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

Наряду с такими простыми конструкциями идентификаторов Maple-язык пакета допускает и более сложные, определяемые несколькими путями. Прежде всего, идентификаторы, начинающиеся с комбинации символов (_Env) полагаются ядром сеансовыми, т. е. их действие распространяется на весь текущий сеанс работы с пакетом. Так как они служат, прежде всего, для изменения пакетных предопределенных переменных, то их использованию следует уделять особое внимание. По конструкции anames('environment') можно получать в текущем сеансе все активные пакетные переменные: > anames('environment');

Testzero, UseHardwareFloats, Rounding, %, %%%, Digits, index/newtable, mod, %%, Order, printlevel, Normalizer, NumericEventHandlers

Ниже данный тип переменных будет нами рассматриваться несколько детальнее. Для обозначения определенного типа числовых значений Maple-язык использует целый ряд специальных идентификаторов таких, как: _N, _NN, _NNp, _Z∼, _Zp∼, _NN∼ и др. Например, _Zp∼ и _NN∼ используются для обозначения целых и целых неотрицательных чисел, тогда как _Cp-переменные используются для обозначения постоянных интегрирования и т.д.

Пакетные переменные такие как Digits, Order, printlevel имеют приписанные им по умолчанию значения соответственно [10, 6, 1], которые можно переопределять в любой момент времени. Однако, если после выполнения restart-предложения, восстанавливающего исходное состояние ядра пакета, сеансовые переменные становятся неопределенными, то пакетные переменные восстанавливают свои значения по умолчанию. Более сложные виды идентификаторов, включающие целые фразы как на английском, так и на национальных языках, можно определять, кодируя их в верхних обратных кавычках; при этом, внутри ограничивающих кавычек могут кодироваться любые символы (при использовании верхних кавычек они дублируются). В случае простого R-идентификатора конструкции R и `R` являются эквивалентными, а при использовании ключевых слов Maple-языка (указанных в 1.1) в качестве идентификаторов они должны кодироваться в верхних обратных кавычках.

Пустой символ, кодируемый в виде ``, также может использоваться в качестве идентификатора, например:

> ``:= 64: ``; ⇒ 64

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

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

Имя(Последовательность фактических аргументов)

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

Вторым способом определения сложных идентификаторов является кодирование объединяющих их составные части ||-оператора конкатенации и/или встроенной cat-функции конкатенации строк, имеющей простой формат кодирования cat(x, y, z, t, ...) и возвращающей объединенную строку (символ) xyzt... , где: x, y, z, t … - строки, символы или

||-операторы (при этом, ||-оператор не может быть первым или последним), как это иллюстрирует следующий весьма простой фрагмент:

При этом, как показывает второй пример фрагмента, тип возвращаемого в результате конкатенации нескольких аргументов значения определяется типом первого аргумента, а именно: если первый аргумент является строкой (символом), то и результат конкатенации будет строкой (символом). Это справедливо как для cat-функции, так и для ||-оператора. Вообще говоря, имеет место следующее определяющее соотношение для обоих методов конкатенации, а именно:

cat(x1, x2, ..., xj, ..., xn) = x1||x2|| ... ||xj|| ... xn

Результат конкатенации должен использоваться в кавычках, если составляющие его компоненты включали специальные символы. Полученные в результате конкатенации символы используются в дальнейшем как единые идентификаторы или просто символьные (строчные) значения. В принципе, допуская конкатенацию произвольных Maple-выражений, функция cat и ||-оператор имеют ряд ограничений, в частности, при использовании их в качестве аргументов и операндов функциональных конструкций, которые могут инициировать некорректные (а в ряде случаев и непредсказуемые) результаты:

> cat(ln(x), sin(x), tan(x)); ⇒ || (ln(x)) || (sin(x)) || (tan(x))

> ` `||F(x)||G(x), " "||F(x)||G(x); ⇒ ( F(x)) || G(x), (" F"(x)) || G(x)

> cat(F(x), G(x)), H||evalf(Pi); ⇒ || (F(x)) || (G(x)), Hevalf(Pi)

> H||(evalf(Pi)); ⇒ H || (3.141592654)

> cat(`sin(x)`, "cos(x)"); ⇒ sin(x)cos(x)

> [A||max(59, 64), A||(max(59, 64))]; ⇒ [Amax(59, 64), A64]

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

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

Наряду с рассмотренными типами Maple-язык допускает использование индексированных идентификаторов, имеющих следующий формат кодирования:

Идентификатор[Последовательность индексов]

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

Однако, при условии V-массива V[k, h]-переменная идентифицирует его (k, h)-элемент. И так как индексированность сохраняет свойство быть идентификатором, то его можно последовательно индексировать, как это иллюстрирует последний пример фрагмента.

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

Идентификатор[Последовательность индексов] {;|:}

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

> L:= [59, 64, 39, 10, 17]: S:={V, G, Sv, Art, Kr}: L[3], S[5], S[3], L[4];

39, Sv, Art, 10

Наконец, идентификатор функции/процедуры кодируется в следующем формате: Идентификатор(Последовательность фактических аргументов)

определяя вызов функции с заданным именем с передачей ей заданных фактических аргументов, например: sin(20.06); ⇒ 0.9357726776.

Для идентификаторов любых конструкций Maple-языка допускается использование алиасов (дополнительных имен), позволяющих обращаться к конструкциям как по их основным именам, так и по дополнительным. Данный механизм языка обеспечивается встроенной alias-функцией, кодируемой в следующем формате: alias(alias_1=Id, alias_2=Id, ... , alias_n=Id)

где Id - основное имя, а alias_j - присваиваемые ему алиасы (j=1..n), например:

> G:= `AVZ`: alias(year = 'G', Grodno = 'G', `ГрГУ` = 'G'); ⇒ year, Grodno, ГрГУ

> [G, year, Grodno, `ГрГУ`]; ⇒ [AVZ, AVZ, AVZ, AVZ]

> alias(e = exp(1)); ⇒ year, Grodno, ГрГУ, e

> evalf(e); ⇒ 2.718281828

В приведенном фрагменте проиллюстрировано, в частности, определение более привычного e-алиаса для основания натурального логарифма, вместо принятого (на наш взгляд не совсем удачного) в пакете exp(1)-обозначения. Алиасы не допускаются только для числовых констант; при этом, в качестве Id-параметров alias-функции должен использоваться невычисленный идентификатор (т.е. кодируемый в апострофах), а не его значение. Если вызов alias-функции завершается (;)-разделителем, то возвращается последовательность всех на текущий момент присвоенных алиасов сеанса работы с ядром пакета. Механизм алиасов имеет немало интересных приложений, детальнее рассматриваемых в наших книгах [10-12,91].

Близкой по назначению к alias-функции является и функция macro формата: macro(X1 = Y1, ...., Xn = Yn)

возвращающая NULL-значение, т.е. ничего, и устанавливающая на период сеанса работы с ядром пакета односторонние соотношения X1 ⇒ Y1, ..., Xn ⇒ Yn. Точнее, любое вхождение Xj-конструкции в Input-параграфе либо при чтении ее из файла замещается на приписанную ей по macro-функции Yj-конструкцию. Исключением является вхождение Xj-конструкций в качестве формальных аргументов и локальных переменных процедур. В данном отношении macro-функция отличается от традиционного понятия макроса и более соответствует однонаправленному алиасу. Функция macro может быть определена для любой Maple-конструкции, исключая числовые константы. Более того, фактические аргументы macro-функции не вычисляются и не обрабатываются другими macro-функциями, не допуская рекурсивных macro-определений. Для изменения определения macro вполне достаточно выполнить новый вызов macro-функции, в которой правые части уравнений имеют другое содержимое. Тогда как для отмены macro-определения достаточно произвести соответствующий вызов функции macro(Xp = Yp). Следующий простой фрагмент иллюстрирует вышесказанное:

> macro(HS=AGN): [AGN(1999), HS(1999)];

[AGN(1999), AGN(1999)]

> alias(AGN=HS): [AGN(1999), HS(1999)];

Warning, alias or macro HS defined in terms of AGN

[335496251958, AGN(1999)]

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

Определение переменной в текущем документе (ТД) является глобальным, т.е. доступным любому другому ТД в течение текущего сеанса работы с ядром пакета. Сказанное не относится к режиму параллельного сервера, когда все загруженные документы являются независимыми. Режим параллельного сервера детально рассмотрен в [9-12]. При этом, определение считается сделанным только после его реального вычисления. После перезагрузки пакета все определения переменных и пользовательских функций/процедур (отсутствующих в библиотеках, логически сцепленных с главной библиотекой пакета) теряются, требуя нового переопределения. Без перезагрузки пакета этого можно добиться по предложению restart, приводящему все установки ядра пакета в исходное состояние (очистка РОП, отмена всех сделанных ранее определений, выгрузка всех загруженных модулей и т.д.), либо присвоением идентификаторам переменных невычисленных значений вида Id:='Id'. Следующий простой фрагмент иллюстрирует вышесказанное:

> x:= 19.42: y:= 30.175: Grodno:= sin(x) + cos(y); ⇒ Grodno := 0.8639257079

> restart; Grodno:= sin(x) + cos(y); ⇒ Grodno := sin(x) + cos(y)

> G:= proc() nargs end proc: G(42, 47, 67, 62, 89, 96); ⇒ 6

> G:= 'G': G(42, 47, 67, 62, 89, 96); ⇒ G(42, 47, 67, 62, 89, 96)

Из фрагмента хорошо видно, что ранее сделанное определение Grodno-переменной отменяется после выполнения restart-предложения. Выполнение restart-предложения следует лишь на внешнем уровне ТД и не рекомендуется внутри ряда его конструкций (функции, процедуры и др.) во избежание возникновения особых и аварийных ситуаций, включая “зависание” пакета, требующее перезагрузки ПК. При этом, следует иметь в виду, что освобождаемая в этом случае память не возвращается операционной среде, а присоединяется к собственному пулу свободной памяти пакета. Поэтому при необходимости получения максимально возможной памяти для решения больших задач пользователю рекомендуется все же производить перезагрузку пакета в Windows-среде. Тогда как второй способ отмены определенности для переменных более универсален. В книге [103] и в прилагаемой к ней Библиотеке представлены средства, обеспечивающие возможность восстановления из процедур исходного состояния объектов. Например, вызов процедуры prestart() очищает все переменные, определенные в текущем сеансе, исключая пакетные переменные.

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

> macro(Salcombe = Vasco): Eesti:= 19.95: Vasco:= Noosphere: Tallinn:= 20.06:

> TRG:= sqrt(Lasnamae*(Eesti + Tallinn)/(Salcombe + Vasco)) + `Baltic Branch`;

Lasnamae

TRG := 4.472694937 + Baltic Branch

Noosphere

Присвоение идентификатору определенного или неопределенного значения производится посредством традиционного (:=)-оператора присвоения вида А:= В, присваивающего левой А-части В-значение. При этом, в качестве левой А-части могут выступать простой идентификатор, индексированный идентификатор или идентификатор функции с аргументами. Точнее, присвоение А-части В-значения корректно, если A имеет assignable-тип, т.е. type(A, 'assignable'); ⇒ true. Вычисленное (или упрощенное) значение В-части присваивается идентификатору А-части.

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

Id1, Id2, …, Idn := <Выражение_1>, <Выражение_2>, …, <Выражение_n>

При этом, при равном количестве компонент правой и левой частей присвоения производятся на основе взаимно-однозначного соответствия. В противном случае инициируются ошибочные ситуации "Error, ambiguous multiple assignment" либо "Error, cannot split rhs for multiple assignment". Следующий фрагмент иллюстрирует случаи множественного присваивания:

> A, B, C:= 64, 59:

Error, ambiguous multiple assignment

> V, G, S, Art, Kr, Arn:= 64, 59, 39, 17, 10, 44: [V, G, S, Art, Kr, Arn];

[64, 59, 39, 17, 10, 44]

> x, y, z, t, h:= 2006: [x, y, z, t, h];

Error, cannot split rhs for multiple assignment

[x, y, z, t, h]

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

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

&ma('x', 'y', 'z', ..., <rhs>) и ('x', 'y', 'z', ...) &ma (<rhs>)

В общем случае, в обоих случаях в конструкции lhs &ma rhs элементы lhs должны быть закодированы в невычисленном формате, т.е. в апострофах ('). Исключение составляет лишь первый случай присвоения. Кроме того, в операторном формате, левая часть lhs должна быть закодирована в скобках. Кроме того, если правая часть rhs удовлетворяет условию type(rhs, {'..', '<', ` <= `, '.', '*', '^', '+', '='}) = true, то правая часть должна также кодироваться в скобках. Наконец, если необходимо присвоить NULL-значение (т. е. ничего) элементам левой части lhs, то в качестве правой части rhs кодируется _NULL-значение. Успешный вызов процедуры `&ma` или применения оператора &ma возвращает NULL-значение, т. е. ничего с выполнением указанных присвоений. В целом ряде приложений оператор/процедура &ma представляются достаточно полезными [103]. Ниже приведен ряд примеров на применение оператора &ma:

Процедурный формат оператора:

> &ma(h(x), g(y), v(z), r(g), w(h), (a + b)/(c - d)); h(x), g(y), v(z), r(g), w(h);

Для проверки идентификатора на предмет его определенности используется встроенная функция assigned языка, кодируемая в виде assigned(Идентификатор) и возвращающая значение true в случае определенности идентификатора (простого, индексированного или вызова функции/процедуры), и false-значение в противном случае. При этом, следует иметь в виду, что определенным идентификатор полагается тогда, когда он был использован в качестве левой части (:=)-оператора присвоения, даже если его правая часть являлась неопределенной. Или он получил присвоение по аssign-процедуре. Следующий простой фрагмент иллюстрирует вышесказанное:

> agn:=1947: avz:=grodno: assign(vsv=1967, art=kr): seq(assigned(k), k=[agn, avz, vsv, art]); true, true, true, true

> map(type,[agn, avz, vsv, art],'assignable'); ⇒ [false, true, false, true]

> map(assigned, [agn, avz, vsv, art]);

Error, illegal use of an object as a name

С другой стороны, по конструкции type(Id, 'assignable') мы можем тестировать допустимость присвоения Id–переменной (простой, индексированной или вызова функции/процедуры) выражения: возврат true-значения говорит о такой возможности, false – нет. Следует обратить внимание на последний пример фрагмента, иллюстрирующий некорректность использования встроенной функции map при попытке организации простого цикла.

Вызов функции indets(W {, <Тип>}) возвращает множество всех идентификаторов заданного его первым фактическим W-аргументом Maple-выражения. При этом, W-выражение рассматривается функцией рациональным, т.е. образованным посредством {+, -, *, /}-операций. Поэтому в качестве результата могут возвращаться не только простые идентификаторы W-выражения, но и неопределенные его подвыражения. В случае кодирования второго необязательного аргумента, он определяет тип возвращаемых идентификаторов, являясь своего рода фильтром. В качестве второго фактического аргумента могут выступать как отдельный тип, так и их множество в соответствии с типами, распознаваемыми тестирующей type-функцией языка, рассматриваемой детально ниже. Следующий фрагмент иллюстрирует применение indets-функции для выделения идентификаторов переменных:

> indets(x^3 + 57*y - 99*x*y + (z + sin(t))/(a + b + c) = G);

{sin(t), x, y, z, t, a, b, c, G}

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

Для возможности использования произвольного А-выражения в качестве объекта, которому могут присваиваться значения, Maple-язык располагает evaln-функцией, кодируемой в виде evaln(A) и возвращающей имя выражения. В качестве А-выражения допускаются: простой идентификатор, индексированный идентификатор, вызов функции/ процедуры или конкатенация символов. В результате применения к А-выражению функции evaln оно становится доступным для присвоения ему значений, однако если ему не было сделано реального присвоения, то применение к нему assigned-функции возвращает значение false, т.е. А-выражение остается неопределенным. Таким образом, по конструкции Id:= evaln(Id) производится отмена присвоенного Id-идентификатору значения, делая его неопределенным, как это иллюстрирует следующий простой фрагмент:

> Asv:= 32: assigned(Asv); Asv:= evaln(Asv): Asv, assigned(Asv); true

Asv, false

> Asv:= 67: assigned(Asv); Asv:= 'Asv': Asv, assigned(Asv); true

Asv, false

Из приведенного фрагмента непосредственно следует, что первоначальное присвоение Asv-идентификатору значения делает его определенным, на что указывает и результат вызова assigned-функции. Тогда как последующее выполнение Asv:=evaln(Asv) предложения делает Asv-идентификатор вновь неопределенным. Вторым способом приведения идентификатора к неопределенному состоянию является использование конструкции вида Id:= 'Id', как это иллюстрирует второй пример предыдущего фрагмента.

Для выполнения присвоений можно воспользоваться и assign-процедурой, допускающей в общем случае три формата кодирования, а именно: assign({A, B|A = B|C}), где А – некоторый идентификатор, В - любое допустимое выражение и С - список, множество либо последовательность уравнений. В первых двух случаях применение assign-процедуры эквивалентно применению (:=)-оператора присвоения, тогда как третий случай применяется для обеспечения присвоения левой части каждого элемента списка, множества или последовательности уравнений. Простой фрагмент иллюстрирует вышесказанное:

> assign(AGn, 59); assign(AVz=64); assign([xx=1, yy=2, zz=3, h=cos(y)*tan(z)]);

> assign({xx1=4, yy1=5, zz1=6, y=x*sin(x)}); [AGn, AVz, xx, yy, zz, xx1, yy1, zz1, y, h];

[59, 64, 1, 2, 3, 4, 5, 6, x sin(x), cos(x sin(x)) tan(z)]

> assign('x', assign('y', assign('z', 64))); [x, y, z]; ⇒ [64] # Maple 7 и выше

> assign('x', assign('y', assign('z', 64))); [x, y, z]; # Maple 6 и ниже Error, (in assign) invalid arguments

> `if`(type(AV, 'symbol') = true, assign(AV, 64), false); AV; ⇒ 64

> GS:= op([57*sin(19.95), assign('VG', 52)]) + VG*cos(19.99); ⇒ GS := 72.50422598

Успешное выполнение assign-процедуры производит указанные присвоения и возвращает NULL-значение, в противном случае инициируется соответствующая ошибочная ситуация. Данная ситуация, в частности, возникает при попытке рекурсивного вызова assign-процедуры для релизов 6 и ниже, тогда как в более старших релизах подобного ограничения нет. По отношению к процедуре assign релизы пакета характеризуются весьма существенной несовместимостью, что стимулировало нас к созданию аналога стандартной процедуры, который не только устраняет указанную несовместимость, но и расширяет функциональные возможности [31,39,41-43,45,46,103]. Это и другие наши средства рассмотрены детально в книге [103] и представлены в прилагаемой к ней Библиотеке программных средств.

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

Обратной к assign-процедуре является unassign-процедура с форматом кодирования: unassign(<Идентификатор_1>, <Идентификатор_2>, ...)

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

В приведенном фрагменте пяти переменным присваиваются целочисленные значения, а затем по unassign-процедуре делается попытка отменить сделанные назначения. Попытка вызывает ошибочную ситуацию, обусловленную тем, что в точке вызова процедуре unassign передаются не сами идентификаторы, а их значения (кстати, именно данная ситуация одна из наиболее типичных при ошибочных вызовах assign-процедуры). Для устранения ее идентификаторы следует кодировать в невычисленном формате (кодируя в апострофах), что иллюстрирует повторный вызов unassign-процедуры. Последний пример иллюстрирует применение процедур assign и unassign в условном if-предложении языка, по которому AV-переменной присваивается целочисленное значение, если она была неопределенной, и отменяется ее определение в противном случае.

Для отмены значений имен, имеющих protected-атрибут, может оказаться достаточно полезной и процедура Unassign('n1', 'n2', ...), возвращающая NULL-значение и отменяющая назначения для имен {'n1', 'n2', ...}, закодированных в невычисленном формате. Ее исходный текст представляется однострочным экстракодом следующего вида: Unassign := ( ) → `if`(nargs = 0, NULL, op([unprotect(args), unassign(args)]))

Приведем примеры применения процедур стандартной unassign и нашей Unassign:

Как следует из приведенного фрагмента, наша процедура Unassign в отличие от стандартной корректно обрабатывает особую ситуацию «отсутствие фактических аргументов», возвращая и в этом случае NULL-значение.

В целях защиты идентификаторов от возможных модификаций их определений (назначений) им присваивается protected-атрибут, делающий невозможной какую-либо модификацию указанного типа. Большинство пакетных идентификаторов имеют protectedатрибут, в чем легко убедиться, применяя к ним attributes-функцию, кодируемую в следующем формате: attributes(<Идентификатор>)

и возвращающую значения атрибутов заданного идентификатора, в частности атрибута protected. Если идентификатору не приписано каких-либо атрибутов, то вызов на нем attributes-функции возвращает NULL-значение, т.е. ничего. Для защиты от модификации либо снятия защиты используются процедуры protect и unprotect Maple-языка соответственно, кодируемые в следующем простом формате:

{protect|unprotect}(<Идентификатор_1>, <Идентификатор_2>, ...)

Следующий весьма простой фрагмент Maple-документа иллюстрирует вышесказанное:

> protect(AV_42); attributes(AV_42); ⇒ protected

> unassign(AV_42);

Error, (in assign) attempting to assign to `AV_42` which is protected > AV_42:= 64:

Error, attempting to assign to `AV_42` which is protected

> unprotect(AV_42); attributes(AV_42); AV_42:= 64; ⇒ AV_42 := 64

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

> map(attributes, [Digits, Order, printlevel]); protect('Digits'); protect('Order'); protect('printlevel'); ⇒ []

Error, (in protect) an Environment variable cannot be protected

Error, (in protect) an Environment variable cannot be protected

Error, (in protect) an Environment variable cannot be protected

Хотя по unprotect-процедуре отменяется protected-атрибут любого идентификатора, однако для пакетных идентификаторов этого (по целому ряду причин, здесь не рассматриваемых) делать не рекомендуется.

В целом ряде случаев в качестве весьма полезных средств могут выступать две встроенные функции со следующими форматами кодирования: unames() и anames({ |<Тип>}), возвращающие последовательности соответственно неопределенных и определенных идентификаторов (как пользовательских, так и пакетных), приписанных текущему Maple-сеансу. При этом, для случая anames-функции можно получать подборку определенных идентификаторов, значения которых имеют указанный Тип. Следующий фрагмент иллюстрирует результат вызова указанных выше функций:

При этом, unames-функция была вызвана в самом начале сеанса работы с пакетом и возвращаемый ею результат представлен только начальным отрезком достаточно длинной последовательности пакетных идентификаторов. Что касается anames-функции, то она в качестве второго необязательного аргумента допускает тип, идентификаторы с которым будут ею возвращаться. При этом, дополнительно к типу и в зависимости от релиза в качестве второго аргумента допускается использование таких параметров как user, environment, alluser, назначение которых можно вкратце охарактеризовать следующим образом. Параметр environment определяет возврат имен предопределенных переменных текущего сеанса пакета, параметр user (введенный, начиная с Maple 9) определяет возврат имен, определенных пользователем, тогда как параметр alluser (введенный, начиная с релиза 10) аналогичен по назначению предыдущему параметру user, но без фильтрации имен пользователя, содержащих прямой слэш «/» и префикс «_» (подчеркивание).

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

> a:= 63: b:= 63: c:= "ransian63": c9:= "ransian63": d:= table([1=63, 2=58, 3=38]): L:= [x, y, z]: assign('h'=`svegal`): t47:= 19.42: t42:= 19.42: R:= a+b*I: B:= a+b*I: Z:= (a1+b1)/(c1+d1): f:=cos(x): g:=proc() `+`(args)/nargs end proc: r:=x..y: m:=x..y: n:= x..y: Lasnamae:= NULL: > Tallinn:=NULL: Grodno:= NULL: Vilnius:= NULL: Moscow:= NULL: map(nvalue, [63, "ransian63", table([1=63,2=58,3=38]), svegal, 19.42, [x,y,z], a+b*I, (a1+b1)/(c1+d1), cos(x), proc () `+`(args)/nargs end proc, x..y]), nvalue(); ⇒ {a, b}, {c9, c}, {d}, {h}, {t47,t42}, {L}, {R,B}, {Z}, {f}, {g}, {m, r, n}, {Tallinn, Grodno, Vilnius, Moscow, Lasnamae}

1.3. Средства Maple-языка для определения свойств переменных

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

assume(x1, p1, x2, p2, ...) assume(x1::p1, x2::p2, ...) assume(x1p1, x2p2, ...)

и позволяет наделять идентификаторы (переменные) или допустимые Maple-выражения xj заданными свойствами pj, т.е. устанавливать определенные свойства и соотношения между ними. Третий формат процедуры определяет соотношения, налагающие свойство pj на выражение xj. Например, простейшие, но весьма часто используемые вызовы assume(x >= 0) процедуры, определяют для некоторой х-переменной свойство быть неотрицательной действительной константой. Наделяемое по assume-процедуре свойство не является пассивным и соответствующим образом обрабатывается Maple-языком пакета при выполнении вычислений либо преобразований выражений, содержащих переменные, наделенные подобными свойствами. Тестировать наличие приписанного х-переменной свойства можно по вызову процедуры about(x), тогда как наделять х-переменную дополнительными свойствами можно по вызову процедуры additionally(x, Свойство). Следующий фрагмент иллюстрирует вышесказанное:

Из примеров данного фрагмента, в частности, следует, что переменная с приписанным ей свойством выводится помеченной символом тильды (∼), а по about-процедуре выводится информация о всех приписанных переменной свойствах либо об их отсутствии. Один из примеров фрагмента иллюстрирует влияние наличия свойства положительной определенности переменной на результат упрощения содержащего ее выражения. В другом примере фрагмента иллюстрируется возможность определения для переменной множественности свойств, определяемых как поддерживаемыми языком стандартными свойствами, так и допустимыми отношениями для переменной. При этом, вызов процедуры hasassumptions(x) возвращает true, если на x-выражение было наложено какое-либо соотношение, и false в противном случае.

Режим идентификации assume-переменных определяется showassumed-параметром процедуры interface, принимающим значение {0|1 (по умолчанию)|2}: 0 - отсутствует идентификация, 1 - переменные сопровождаются знаком тильды и 2 - все такие переменные перечисляются в конце выражений, как это иллюстрирует следующий фрагмент:

> assume(V >= 64): assume(G >= 59): S:= V+G; interface(showassumed=0); V + G;

S := V~ + G~

V + G

> assume(Art >= 17, Kr >= 10): interface(showassumed=2): S^2 + (Art + Kr)^2;

S² + (Art + Kr)²

with assumptions on Art and Kr

> assume(x, 'odd', y::integer, z >= 0), is(x + y, 'integer'); ⇒ true

> x:= 'x': unassign('y'), map(is, [x, y], 'integer'), is(z, 'nonnegative'); ⇒ [false, false], true

До 7-го релиза включительно оперативно переопределять режим идентификации переменных assume можно было переключателями функции Assumed Variables группы Options GUI.

По тестирующей процедуре is(x, Свойство) возвращается true-значение, если х-переменная обладает указанным вторым фактическим аргументом свойством, и значение false в противном случае. При невозможности идентифицировать для х-переменной свойство (например, если она по assume-процедуре свойствами не наделялась) возвращается FAIL-значение. Наконец, отменять приписанные х-переменной свойства можно посредством выполнения простой конструкции x:= 'x' либо вызовом процедуры unassign('x'); сказанное иллюстрируют последние примеры предыдущего фрагмента. При этом, проверять можно как конкретную отдельную переменную, так и выражение по нескольким ведущим переменным и набору искомых свойств.

Maple-язык поддерживает работу со свойствами шести основных групп, а именно:

1) имя свойства, например, continuous, unary;

2) большинство имен типов, например, integer, float, odd, even;

3) числовые диапазоны, например, RealRange(a, b), RealRange(-infinity, b),

RealRange( a, infinity), где a и b могут быть или числовыми значениями или Open(a), где a – числовое значение

4) AndProp(a, b, ...) – and-выражение свойств <a and b and ...>, где a, b, ... – свойства, оп- ределенные выше

5) OrProp(a, b, ...) – or-выражение свойств, где объект может удовлетворять любому из a, b, ... свойств

6) диапазон свойств p1 .. p2, где p1 и p2 - свойства. Данное свойство означает, что объект удовлетворяет по меньшей мере p2, но не более, чем p1; например, integer .. rational удовлетворяется integers/2.

За более детальной информацией по поддерживаемым Maple-языком свойствам остальных групп можно обращаться или к справке по пакету, или к книгам [8-14,78-86,88,105].

Механизм свойств, определяемый процедурой assume и сопутствующей ей группой процедур coulditbe, additionally, is, about, hasassumptions и addproperty, использует специальную глобальную _EnvTry-переменную для определения режима как идентификации у переменных приписанных им свойств, так и их обработки. При этом, данная переменная допускает только два значения: normal (по умолчанию) и hard, из которых указание второго значения может потребовать при вычислениях существенных временных затрат. В текущих реализациях пакета значение глобальной _EnvTry-переменной, определяющей режим обработки переменных, наделенных assume-свойствами, не определено, что иллюстрирует следующий достаточно прозрачный фрагмент:

Механизм приписанных свойств является достаточно развитым и мощным средством как числовых вычислений, так и символьных вычислений и преобразований. Использование его оказывается весьма эффективным при программировании целого ряда важных задач во многих приложениях. Последние примеры предыдущего фрагмента иллюстрируют некоторые простые элементы его использования в конкретном программировании. Тогда как конкретный assume-механизм базируется на алгоритмах Т. Вейбеля и Г. Гоннета. С интересным обсуждением принципов его применения, реализации и ограничений можно довольно детально ознакомиться в интересных работах указанных авторов, цитируемых в конце справки по пакету (см. ?assume), и цитируемых в них многочисленных источниках различного назначения.

В ряде случаев требуется выполнить обмен значениями между переменными. Например, переменные х, у и z, имеющие значения 64, 59 и 39 должны получить значения 39, 59 и 64 соответственно. Следующая процедура varsort решает данную задачу.

Вызов varsort('x', 'y', 'z', …) возвращает NULL-значение, обеспечивая обмен значениями между переменными x, y, z, … в порядке возрастания. Подробнее с возможностями данной процедуры можно ознакомиться в [41-43,103,109].

1.4. Типы числовых и символьных данных Mapleязыка пакета

Средства Maple-языка поддерживают работу как с простыми, так и сложными типами данных числового или символьного (алгебраического) характера. В первую очередь рассмотрим типы простых данных числового характера, предварив краткой информацией по очень важным встроенным функциям nops и op, непосредственно связанных со структурной организацией Maple-выражений. Первая функция возвращает число операндов выражения, заданного ее единственным фактическим аргументом. Тогда как вторая имеет более сложный формат кодирования следующего вида: op({ |n,|n..m,|<Список>,} <Выражение>)

где первый необязательный фактический аргумент определяет возврат соответственно: n-го операнда, с n-го по m-й операнды или операнды согласно Списка их позиций в порядке возрастания уровней вложенности Выражения. При этом, при n = 0 возвращается тип самого выражения, а в случае отсутствия указанного первым аргументом операнда инициируется ошибочная ситуация. Для случая n<0 выполняется соотношение op(n,V) ≡ op(nops(V) + n + 1, V), где V – выражение, а для неопределенного Id-идентификатора имеют место соотношения: op(0, Id) ⇒ symbol и op(1, Id) ⇒ Id. Отсутствие первого аргумента op-функции аналогично вызову вида op(1 .. nops(V), V). Для вывода структурной организации произвольного выражения может оказаться полезной конструкция вида: op('k', <Выражение>) $'k'=0 .. nops(<Выражение>)

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

> Art:= 3*sin(x) + 10*cos(y)/AV + sqrt(AG^2 + AS^2)*TRG: op('k', Art)$'k'=0 .. nops(Art);

10 cos(y) ² + AS² TRG

+, 3 sin( )x , , AG

AV

Ниже будет рассмотрено достаточно средств Maple-языка, ориентированных на задачи символьной обработки выражений, включая и те, которые базируются на их структурном ана-изе. Целый ряд средств для решения подобных задач предоставляет и наша Библиотека [103]. Нам же для дальнейшего будет пока вполне достаточно информации по встроенным функциям nops и op пакета.

• Целые (integer); представляют собой цепочки из одной или более цифр, максимальная длина которых определяется используемой платформой ЭВМ: так для 32-битной она не превышает 524280 цифр, а для 64-битной – 38654705646 цифр. Целые могут быть со знаком и без: 1999, -57, 140642. На числах данного типа функции op и nops возвращают соответственно значение числа и значение 1, тогда как функция type идентифицирует их тип как integer, например:

> op(429957123456789), nops(429957123456789); ⇒ 429957123456789, 1

> type(429957123456789, 'integer'); ⇒ true

• Действительные (float) с плавающей точкой; представляют собой цепочки из десятичных цифр с десятичной точкой в {начале|середине|конце} цепочки; числа данного типа допускают следующие два основных формата кодирования:

[<знак>]{<целое>.<целое>|.<целое>|<целое>.}

Float([<знак>]<мантисса>, [<знак>]<экспонента>) ≡

[<знак>]<мантисса>.{E|e}[<знак>]<экспонента>

В качестве мантиссы и экспоненты используются целые со знаком или без; при этом, мантисса может иметь любую длину, но экспонента ограничивается длиной машинного слова: для 32-битной платформы значение экспоненты не превышает целого 2147483647, а для 64-битной платформы – целого значения 9223372036854775807. Тогда как максимальное допустимое число цифр мантиссы аналогично максимальному допустимому числу цифр целого (integer) числа. Число цифр мантиссы, участвующих в операциях арифметики с плавающей точкой, определяется предопределенной Digits-переменной ядра пакета, имеющей по умолчанию значение 10. В книге [103] представлен ряд полезных средств, позволяющих оформлять числовые значения в принятых для документирования и печати форматах.

Второй способ кодирования действительных чисел применяется, как правило, при работе с очень большими или очень малыми значениями. Для конвертации значений в действительный тип используется evalf-функция, возвращающая значение float-типа. В вышеприведенных примерах применение данной функции уже иллюстрировалось; функция имеет простой формат кодирования evalf(<Выражение> [, n]) и возвращает результат float-типа вычисления выражения (действительного или комплексного) с заданной n-точностью (если она определена вторым фактическим аргументом). Maple испытывает затруднения при вычислениях уже целого ряда простых радикалов с рациональными степенями от отрицательных значений, если знаменатель экспоненты – нечетное число. В этом случае даже стандартная функция evalf оказывается бессильной совместно с использованием пакетного модуля RealDomain, что очень хорошо иллюстрируют довольно простые примеры, а именно:

> R:=(58 + (-243)^(1/5) + (-8)^(2/3))*(10 + (-1331)^(2/3) + (-8)^(2/3))/((63 +(-32)^(4/5) - (-27)^

(2/3))* (17 + (343)^(2/3) + (-32)^(3/5))); with(RealDomain): evalf(R), Evalf(R);

^R := (58 + (-243)((14//55)) + (-8)(2(/32)/3))(10 + (-1331)(2/3()2/3) + (-8)(3(/52)/3))

(63 + (-32) − (-27) ) (17 + 343 + (-32) )

-0.7722517003 + 1.867646862 I, 1.961822660

Тогда как процедура Evalf, находящаяся в упомянутой Библиотеке [103], вполне успешно решает данную задачу, что и иллюстрируе данный пример в среде Maple 10.

Практически все встроенные функции пакета возвращают результаты float-типа, если хоть один из их аргументов получает значение данного типа. Автоматически результат операции возвращается float-типа, если один из операндов имеет данный тип. По умолчанию число цифр выводимого действительного числа равно 10, но в любое время может переопределяться в глобальной Digits-переменной ядра пакета. Примеры: 1.42, -.57, 17., 8.9, 2.9E-3, -5.6e+4, -5.4E-2. При этом, конструкции типа <целое>.{E|e}<целое> вызывают синтаксическую ошибку с диагностикой "missing operator or `;`".

Третьим способом определения действительных чисел является функция Float(<мантисса>, <экспонента>), возвращающая число float-типа с указанными мантиссой и экспонентой, например: Float(2006, -10); ⇒ 0.2006e-6. Иногда Float-функцию называют конструктором float-чисел.

Действительное число имеет два операнда: мантиссу и экспоненту, поэтому вызов функции op({1|2}, <число>) соответственно возвращает {мантиссу|экспоненту} указанного ее вторым аргументом числа, тогда как вызов функции nops(<число>) возвращает значение 2 по числу операндов; при этом, функция type идентифицирует тип таких чисел как float, например:

> op(2, 19.95e-10), op(1, 19.95e-10), nops(19.95e-10); ⇒ -12, 1995, 2 > type(19.95e-10, 'float'); ⇒ true

Вопросы арифметики с числами float-типа детально рассматриваются, например, в книгах [12,13] и в ряде других изданий, поэтому ввиду наших целей здесь они не детализируются. Впрочем, данный тип числовых выражений и так достаточно прозрачен.

• Рациональные (rational); представляют собой числа (дроби), кодируемые в форме вида [<знак>] a/b, где a и b - целые числа; в частности, целые числа также рассматриваются пакетом в качестве частного случая рациональных, имеющих единичный знаменатель. Для перевода рациональных чисел в числа float-типа используется упомянутая выше evalf-функция, например: -2, 64, 59/47, -2006/9, evalf(59/47)=1.255319149. На числах данного типа функции op и nops возвращают соответственно значение числителя, знаменателя и значение 2 по числу операндов, тогда как функция type идентифицирует тип таких чисел как fraction или rational, например:

> op(350/2006), nops(350/2006); ⇒ 175, 1003, 2

> type(350/2006, 'fraction'), type(350/2006, 'rational'); ⇒ true, true

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

• Комплексные (complex); представляют собой числа вида a+b*I (b ≠ 0), где a и b – числа рассмотренных выше трех типов, а I – комплексная единица (I = √-1). Части a и b комплексного числа называются соответственно действительной и мнимой; отсутствие второй делает число действительным. Примеры: -19.42 + 64*I, 88.9*I, 57*I/42. Для комплексных чисел различаются целые, действительные, рациональные и числовые в зависимости от того, какого типа их действительная и мнимая части. Например, число 64 - 42*I полагается комплексным целочисленным, тогда как числовое комплексное предполагает числовыми действительную и мнимую части. На числах комплексного типа функции op и nops возвращают соответственно значения действительной и мнимой частей, и число 2 операндов, тогда как функция type идентифицирует тип таких чисел как complex (может указываться и подтип), например:

> op(64 - 42*I), nops(64 - 42*I); ⇒ 64, -42, 2

> type(64 - 42*I, 'complex'('integer')); ⇒ true

Следует отметить, что Maple-языком некорректно распознается тип вычисления ряда комплексных выражений, ориентируясь только на наличие в вычисляемом выражении комплексной I-единицы. Следующий простой пример иллюстрирует вышесказанное:

> type(I*I, ‘complex’), type(I^2, ‘complex’), type(I^4, ‘complex’), type(52 + b*I, ‘complex’({‘symbol’, ‘integer’})), type(a + 57*I, ‘complex’({‘symbol’, ‘integer’})); true, true, true, true, true

> type(I*I, ‘complex1’), type(I^2, ‘complex1’), type(I^4, ‘complex1’), type(52 + b*I, ‘complex1’({‘symbol’, ‘integer’})), type(a + 57*I, ‘complex1’({‘symbol’, ‘integer’})); false, false, false, true, true

Согласно соглашениям пакета вызов функции type(x, complex) возвращает true, если x – выражение формы a+b*I, где a (при наличии) и b (при наличии) конечны, имея тип realcons. В принципе, с формальной точки зрения все нормально. Однако в целом ряде случаев необходимо точно идентифицировать комплексный тип, имеющий форму a + b*I при b ≠ 0. С этой целью нами был дополнительно определен тип complex1 [103], решающий данную задачу. В предыдущем фрагменте можно сравнить результаты тестирования на типы complex и complex1.

• Булевские (boolean); представляют собой логические значения true (истина), false (ложь) и FAIL (неопределенная истинность). Третье значение используется в случае, когда истинность какого-либо выражения неизвестна. Функция type идентифицирует тип таких значений как boolean, например:

> map(type, [true, false, FAIL], ‘boolean’); ⇒ [true, true, true]

Язык Maple использует трехзначную логику для выполнения операций булевой алгебры. Булевы выражения образуются на основе базовых логических операторов {and, or, not} и операторов отношения {<, <=, >, >=, =, <> (не равно)}. Наша Библиотека [103] определяет ряд достаточно полезных средств, расширяющих стандартные средства пакета для работы с булевой алгеброй.

• Константы (constant); представляют собой постоянные значения любого из вышерассмотренных пяти типов. Данные конструкции весьма прозрачны и особых пояснений, так же как и иллюстрирующих их примеров, не требуют.

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

(1) целые числа со знаком (1942; -324; 34567; -43567654326543; 786543278);

(2) действительные со знаком (19.95; -345.84; 7864.87643; -63776.2334643);

(3) рациональные со знаком (18/95; -6/28; -4536786/65932; 765987/123897);

(4) комплексные числа (48+53*I; 28.3-4.45*I; ½+5/6*I; -4543.87604+53/48*I)

Каждый из перечисленных типов числовых данных идентифицируется специальным идентификатором: integer – целые; float – действительные с плавающей точкой; rational, fraction – рациональные (дроби вида m/n; m, n – целые) и complex – комплексные числа. Каждый из этих идентификаторов может быть использован для тестирования типа переменных и выражений посредством type-функции, уже упоминаемой выше, но детально рассматриваемой ниже.

Для обеспечения работы с числовыми значениями Maple-язык располагает как функциями общего назначения, так и специальными, ориентированными на конкретный числовой тип. Например, по функциям ifactor, igcd, iperflow возвращается соответственно: разложение на целочисленные множители целого числа, наибольший общий делитель целых чисел и результат проверки целого числа на возможность представления его в виде n^p , где n и p – оба целые числа, например: [ifactor(64), iperfpow(625, 't'), igcd(42, 7)], t; ^⇒ [(2)⁶ , 25, 7], 2. Детально как с общими, так и специальными функциями работы с числовыми выражениями можно ознакомиться в книгах [12,103], в других изданиях, но наиболее полно в справке по пакету.

Наряду с десятичными числовыми значениями пакет поддерживает работу с бинарными, 8- и 16-ричными, а также произвольными q-ричными числами (q - основание системы счисления). Для преобразования чисел из одной системы счисления в другую служит функция convert языка, рассматриваемая ниже. Наряду с числовыми данными, пакет поддерживает работу с нечисловыми (символьными, алгебраическими) выражениями, характеризуемыми тем, что им не приписаны какие-либо числовые значения. С символьными данными и их обработкой познакомимся детальнее несколько позднее. Здесь лишь отметим базовый тип символьных данных – данные типов string и symbol.

• Строка (string); любая конечная последовательность символов, взятая в верхние двойные кавычки; данная последовательность может содержать и специальные символы, как это иллюстрирует следующий простой пример:

“Dfr@t4#\78578”; “A_V_Z; A+G-N; “” 574%!@#$%”; “_Vasco&Salcombe_2006”

На строках функции op и nops возвращают соответственно саму строку и количество 1 операндов, тогда как функция type идентифицирует тип таких выражений как string, например:

> op(“123456”), nops(“123456”), type(“123456”, ‘string’); ⇒ “123456”, 1, true

• Символ (symbol, name); любая конечная последовательность символов, взятая в верхние обратные кавычки; данная последовательность может содержать и специальные символы, как это иллюстрирует следующий простой пример:

`Dfr@t4#\78578`; `A_V_Z; A+G-N; “” 574%!@#$%`; `_Vasco&Salcombe_2006`; AVZ

Между тем, в отличие от строк, требующих обязательного ограничивания их двойными кавычками, для символов ограничения верхними обратными кавычками требуется только в том случае, когда они содержат специальные символы, например, пробелы. На символах функции op и nops возвращают соответственно сам символ и число 1 операндов, тогда как type-функция идентифицирует тип таких выражений как symbol либо name, например:

> op(`123456`), nops(`12345`), map2(type,`123456`, [‘symbol’, ‘name’]); ⇒ 12345, 1, [true, true]

В отличие от 4-го релиза последующие релизы Maple четко различает понятия символа и строки. Символьный тип играет основополагающую роль в символьных (алгебраических) вычислениях и обработке информации. Строчные данные, наряду с символьными, играют основную роль при работе с символьной информацией и Maple-язык располагает для работы с ними довольно развитыми средствами, которые с той или иной степенью полноты рассматриваются нами ниже. Немало дополнительных средств для работы с выражениями типов {symbol, name, string} представлено и нашей Библиотекой [103]. Многие из них позволяют весьма существенно упростить программирование целого ряда приложений в среде пакета Maple релизов 8 – 10.

Например, процедура _ON(expr) обеспечивает конвертацию алгебраического выражения expr в стилизованный формат, в котором каждое float-число представляется в виде n.m.

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

Тогда как процедура Evalf(x) совместно с процедурой ffp устраняет затруднения Maple при вычислениях ряда простых радикалов х с рациональными степенями от отрицательных значений, если знаменатель их показателя – нечетное число [41-43,103,109].

1.5. Базовые типы структур данных Maple-языка

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

• Последовательность (sequence) – последовательная структура, широко используемая пакетом для организации как ряда других типов структур данных, так и для разнообразных вычислительных конструкций, представляет собой базовую структуру данных и определяется конструкциями следующего весьма простого вида:

Sequence := B1, B2, B3, ..., Bn; Bj (j=1..n) – любое допустимое выражение языка

Последовательность не является ни списком, ни множеством, но она лежит в основе определения этих типов структур данных пакета. Пример: GLS:= 47, Gr, -64*L, `99n+57`, F. Структура типа последовательность выражений или просто последовательность (exprseq), как уже отмечалось, образуется (,)-оператором разделителя выражений (запятая) и представляет интерес не только в качестве самостоятельного объекта в среде Maple-языка, но и в качестве основы таких важных структур как: функциональная, список, множество и индексированная. Важным свойством данного типа структуры данных является то, что если ее элементы также последовательности, то результатом является раскрытая единая последовательность, как это иллюстрирует следующий простой пример:

> AV:= a, b, c, d, e: GS:= x, y, z: Sv:=2, 9: AG:= 1, 2, 3, AV, 4, Sv, 5, 6, GS; AG := 1, 2, 3, a, b, c, d, e, 4, 2, 9, 5, 6, x, y, z

Длина произвольной SQ-последовательности (число ее элементов) вычисляется по конструкции nops([SQ]), тогда как ее k-й элемент получаем посредством оператора выделения SQ[k]. Оператор выделения имеет весьма простой вид: Id[<Выражение>], где Id – идентификатор структуры типа массив, список, множество или последовательность; значение выражения Id[k] определяет искомый элемент структуры. Если Id не определен, то он возвращается индексированным, например:

Так как по конструкции вида SQ[k]:=<Выражение> недопустимо присвоение заданного выражения k-му элементу SQ-последовательности, то для этих целей можно воспользоваться цепочкой Maple-предложений вида: SQ:=[SQ]:SQ[k]:= <Выражение>: SQ:=op(SQ):, как это иллюстрирует второй пример последнего фрагмента. При этом, следует иметь в виду, что тип последовательности тестируется только whattype-процедурой языка, т. к. при передаче последовательности в качестве аргумента другим тестирующим функциям она рассматривается как последовательность фактических аргументов. Последние три примера предыдущего фрагмента иллюстрируют сказанное. Для прямого тестирования структур типа `expressions sequence` нами была определена процедура typeseq, описанная в книге [103] и включенная в прилагаемую к ней Библиотеку [109]. Ниже дано несколько примеров ее применения, а именно:

> typeseq("Kr",Art,6,14,"RANS",IAN,Tallinn, 'seqn'(integer, string, symbol)); ⇒ true

> typeseq(a, b, 10, 17, 'seqn'), typeseq("Kr", Art, 10, 17, "RANS", IAN, Tallinn, Vilnius, 'seqn'), typeseq(G, [a], {b}, 61, 10/17, 'seqn'('integer', 'symbol', 'list', 'set', 'fraction'));

true, true, true

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

<Выражение_1> .. <Выражение_n>

где вычисляемые выражения определяют соответственно нижнюю и верхнюю границы ран-жирования с шагом 1. В зависимости от места использования ранжированной конструкции для значений выражений допускаются значения типов {float, integer}. Особо самостоятельного значения ранжированное выражение не имеет и используется в качестве ранжирующей компоненты во многих стандартных Maple-конструкциях (последовательностные структуры, суммирование, произведение, интегрирование и др.). В качестве самостоятельного применения оператор ранжирования можно использовать, например, с ||оператором конкатенации для создания последовательностей, например:

> n:= 1: m:= 9: SL:= x||(n .. m); ⇒ SL := x1, x2, x3, x4, x5, x6, x7, x8, x9

> A||("g" .. "s"); ⇒ Ag, Ah, Ai, Aj, Ak, Al, Am, An, Ao, Ap, Aq, Ar, As

> A||("м" .. "э"); ⇒ Ам, Ан, Ао, Ап, Ар, Ас, Ат, Ау, Аф, Ах, Ац, Ач, Аш, Ащ, Аъ, Аы, Аь, Аэ

> GS(x||(1 .. 5)):= (x1*x2*x5 + sin(x4 + x5))*(x1^2 + x2^2 + x3^2 + x4^2);

GS(x1, x2, x3, x4, x5) := (x1 x2 x5 + sin(x4 + x5)) (x1 + x2 + x3 + x4)

> A||(1 .. 3)||(4 .. 7); ⇒ A14, A15, A16, A17, A24, A25, A26, A27, A34, A35, A36, A37

Из приведенного фрагмента четко прослеживается одно существенное отличие бинарного ||-оператора конкатенации от других бинарных операторов Maple-языка. Если стандартным в языке является порядок вычисления выражений «слева направо», то для ||-оператора конкатенации используется обратный ему порядок вычислений. В последнем примере вычисляется сначала правый операнд, а затем левый. Более того, из второго и третьего примеров явствует, что наряду с числовыми значениями для ранжированной конструкции допускаются и буквы английского и национальных алфавитов, закодированные в строчном формате. На ранжированных выражениях функции op и nops возвращают соответственно последовательность их левых и правых частей, и число 2 операндов, тогда как функция type идентифицирует тип таких выражений как range, например:

> op(a .. b), nops(a .. b); ⇒ a, b, 2

> type("a" .. "z", 'range'), type(1 .. 64, 'range'), type(-1 .. -6.4, 'range'); ⇒ true, true, true

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

V(k) $ k = p .. n; ⇒ V(p), V(p + 1), ... ,V(n) seq(V[k], k = p .. n); ⇒ V(p), V(p + 1), ... ,V(n)

где V – допустимое Maple-выражение, в общем случае зависящее от к-переменной ранжирования. Следующий простой фрагмент иллюстрирует примеры структур типа последовательности, образованные $-оператором и seq-функцией Maple-языка:

> G(h) $ h = 9.42 .. 14.99; ⇒ G(9.42), G(10.42), G(11.42), G(12.42), G(13.42), G(14.42)

> seq(G(x), x = 9.42 .. 14.99); ⇒ G(9.42), G(10.42), G(11.42), G(12.42), G(13.42), G(14.42)

> 67 $ 15; ⇒ 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67

> Gs $ h = -0.25 .. 7.99; ⇒ Gs, Gs, Gs, Gs, Gs, Gs, Gs, Gs, Gs

> cat(seq(x, x = "a" .. "z")); ⇒ "abcdefghijklmnopqrstuvwxyz"

> cat(seq(x, x = "A" .. "Z")); ⇒ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

> H:= [x, y, z, h, r, t, k, p, w, z, d]: H[s] $ s=1 .. 11; ⇒ x, y, z, h, r, t, k, p, w, z, d

> seq(H[s], s = 1 .. 11); ⇒ x, y, z, h, r, t, k, p, w, z, d

С учетом сказанного приведенный фрагмент весьма прозрачен и особых пояснений не требует. Более детально вопросы, связанные с $-оператором и seq-функцией, будут рассмотрены в связи с обсуждением функциональных средств языка. Здесь лишь отметим, что при всей близости обоих средств между ними существует различие, выражающееся в более универсальном характере seq-функции в плане ее применимости для генерации последовательностей, что будет проиллюстрировано ниже на примерах и детально рассмотрено в [12,41-43,103].

• Список (list) – списочная структура, широко используемая пакетом для организации вычислений и обработки разнообразной информации, образуется посредством помещения последовательности выражений в квадратные скобки, формируя конструкцию следующего общего вида:

List := [B1, B2, B3, ..., Bn], где Bj (j=1 .. n) – любое допустимое выражение Maple-языка

Длина списка определяется числом входящих в него элементов, а идентичными полагаются списки, имеющие одинаковую длину и одинаковые значения соответствующих элементов. По конструкции вида List[n] можно получать значение n-го элемента списка с List-идентификатором, а на основе вызова функции nops(List) – число его элементов. При этом, по вызову функции op(List) можно конвертировать списочную List-структуру в последовательность. Замена к-го элемента списка L выполняется по конструкции L[k] := <Выражение>, тогда как для его удаления используется конструкция subsop(k = NULL, L). Функция type идентифицирует тип списочных структур как list. Следующий простой пример иллюстрируют вышесказанное:

> L:=[sqrt(25),September,2,2006,GS]: [L[4],nops(L)],op(L); ⇒ [2006,5], 5,September,2, 2006,GS

> L[2]:= October: L; L:= subsop(3 = NULL, L): L, type(L, 'list'); ⇒ [5, October, 2, 2006, GS] [5, October, 2006, GS], true

Между тем, для удаления к-го элемента списка L с последующим обновлением списка «на месте» можно использовать конструкцию вида L[k] := 'NULL', весьма удобную в целом ряде приложений. Однако данный подход, корректно работая в одиночных вычислениях, не дает искомого результата в циклических. Поэтому во втором случае после каждого вычисления вида L[k]:= 'NULL' следует использовать операцию присвоения L:= L. Следующий весьма простой фрагмент иллюстрирует вышесказанное:

> restart; L:= [q, w, e, r, t, y, u, j, o, p, a, d, g, h, k, z, x]: L[10]:= 'NULL': L;

[q, w, e, r, t, y, u, j, o, a, d, g, h, k, z, x]

> L:=[q,w,e,r,t,y,u,j,o,p,a,d,g,h,k,z,x]: while L <> [] do L[1]:= 'NULL': L:= L end do: L ⇒ []

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

> L:= [q,w,e,r,t,y,u,j,o,p,d,a,s,k,x,z,y]: subsop(5 = VSV, L), subsop(10 = NULL, L), L;

[q, w, e, r, VSV, y, u, j, o, p, d, a, s, k, x, z, y], [q, w, e, r, t, y, u, j, o, d, a, s, k, x, z, y],

[q, w, e, r, t, y, u, j, o, p, d, a, s, k, x, z, y]

> mlist:= proc(L::uneval, a::posint, b::anything) if type(eval(L), 'list') then if belong(a, 1 ..

nops(eval(L))) then L[a]:= b; L:=eval(L); NULL else error "in list <%1> does not exist

Вызов процедуры mlist(L, a, b) возвращает NULL-значение, заменяя a-й элемент списка L на Maple-выражение b; при этом, обновление списка производится «на месте». Тогда как вызов процедуры mlist(L, a, 'NULL') также возвращает NULL-значение, удаляя a-й элемент из списка L и обновляя список «на месте». В ряде приложений процедура mlist представляется достаточно полезной.

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

> Avz:= [[[1, 2, 3], [5, 6]], [6, G], V, S]: op(Avz), nops(Avz); ⇒ [[1, 2, 3], [5, 6]], [6, G], V, S, 4

Для вложенных списков, чьи элементы имеют одинаковую длину, Maple определяет тип listlist, играющий весьма важную роль при организации индексированных структур (матрица, массив и др.). Нами дополнительно определен тип nestlist [103], характеризующий более общий тип вложенности списков, например:

> Avz:= [[[1, 2, 3], [5, 6]], [6, G], V, S]: type(Avz, 'listlist'), type(Avz, 'nestlist'); ⇒ false, true > Agn:= [[1, 2, 3], [a, b, c], [x, y, z]]: type(Agn, 'listlist'), type(Agn, 'nestlist'); ⇒ true, true Пустой список обозначается как L0:=[] и nops(L0); ⇒ 0, op(L0); ⇒ NULL. Maple-язык располагает весьма обширным набором функциональных средств для работы со списочными структурами, которые будут рассматриваться нами довольно детально ниже. Пакетный модуль ListTools содержит набор средств для работы со списками. В свою очередь, наша Библиотека [103] также содержит ряд полезных средств для такого типа структур.

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

• Множество (set) – структура данных, весьма широко используемая пакетом, в первую очередь, для организации вычислений в традиционном теоретико-множественном смысле, образуется посредством помещения последовательности в фигурные скобки, формируя конструкцию следующего простого вида:

Set := {B1, B2, B3, ..., Bn}, где Bj (j=1 .. n) – любая допустимая конструкция Maple-языка

Мощность множества определяется числом входящих в него элементов, а идентичными полагаются множества, имеющие одинаковый набор вычисленных значений элементов без учета их кратности. По конструкции вида Set[n] можно получать значение n-го элемента множества с Set-идентификатором, а на основе вызова функции nops(Set) - число его элементов. Более того, по вызову функции op(Set) можно конвертировать Set-множество в последовательность. При этом, функция type идентифицирует тип множественных структур как set. Следующий пример иллюстрируют вышесказанное:

> Set1:= {q,6/3,e,r,5,t,w}: Set2:= {q,w,e,r,2,t,w,sqrt(25),r,q,q}: [op(Set1)], [op(Set2)],

[nops(Set1)], [nops(Set2)], Set2[5]; ⇒ [2, 5, r, q, e, t, w], [2, 5, r, q, e, t, w], [7], [7], e

Из приведенного примера можно заметить ряд особенностей применения функций op и nops к структуре данных set-типа. Прежде всего, производится вычисление элементов множества и их упорядочивание согласно соглашениям пакета, поэтому порядки элементов исходного множества и результата его вычисления могут не совпадать. Это же относится и к мощности множества - в результате вычисления его элементов одинаковые результаты сводятся к одному, например: S := {56/2, 7*4, 28, 7*2^2}: nops(S); ⇒ 1. Пустое множество обозначается как S0:= {} и nops(S0); ⇒ 0, op(S0); ⇒ NULL.

Maple-язык поддерживает ряд операций над множествами, аналогичных классическим теоретико-множественным операциям, включая базовые операции объединения (union), разности (minus) и пересечения (intersect) множеств, например:

> S1:= {q,r,64,t,w,x,h,z}: S2:= {h,n,v,x,59,z,k,s}: S1 union S2, S1 intersect S2, S2 minus S1;

{59, 64, x, h, s, z, n, r, v, q, t, w, k}, {x, h, z}, {59, s, n, v, k}

Множества могут иметь различный уровень вложенности, определяя различного рода структуры данных и конструкции. Нами дополнительно определен тип setset [103], аналогичный стандартному типу listlist для случая списков, например:

> map(type, [{{}}, {{},{}}, {{{7}}}, {{a, b}, {c, d}}, {{a, b}, {c}}, {{10, 17}, {64, 59}, {39, 44}}], 'setset');

[true, true, true, true, false, true]

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

Одной из наиболее полезных и часто используемых над объектами типов set и list является map-функция Maple-языка, имеющая в общем виде формат кодирования:

map(F, f(x, y, z, ...), a, b, c, …) ⇒ f(F(x, a, b, c, …), F(y, a, b, c, …), F(z, a, b, c, …), ...)

где F – некоторая функция или процедура, f – выражение от переменных x, y, z, ... и a, b, c, … – некоторые выражения, и возвращающая результат применения функции или процеду-ры F к каждому аргументу f(x, y, z, ...)-конструкции (а в более общей постановке, к каждому операнду выражения), как это иллюстрирует следующий простой фрагмент:

> map(F, [x, y, z], a, b, c, d); ⇒ [F(x, a, b, c, d), F(y, a, b, c, d), F(z, a, b, c, d)]

> map(F, {x, y, z}, a, b, c, d); ⇒ {F(x, a, b, c, d), F(y, a, b, c, d), F(z, a, b, c, d)}

> map(F, f(x, y, z), a, b, c, d); ⇒ f(F(x, a, b, c, d), F(y, a, b, c, d), F(z, a, b, c, d))

> Seq:= x, y, z: map(F, Seq, a, b, c, d); ⇒ F(x, y, z, a, b, c, d)

Между тем, если по map(F, V, a1, ..., an)-функции применяется определенная ее первым фактическим F-аргументом функция к каждому операнду V-выражения с передачей ей дополнительных фактических aj-аргументов (j=1..n), то по ее модификации – функции map2 вида map2(F, a1, V, a2, ..., an) производится применение к V-выражению F-функции со специфическим a1-аргументом и возможностью передачи ей дополнительных aj-аргументов (j=2 .. n), что является существенным расширением map-функции. Следующий пример иллюстрирует принцип формального выполнения map2-функции:

> map2(F, a1, [x,y,z], a, b, c, d, e); ⇒ [F(a1, x, a, b, c, d, e),F(a1, y, a, b, c, d, e),F(a1, z, a, b, c, d, e)]

> map2(S, x, G(a, b, c), y, z, h, t); ⇒ G(S(x, a, y, z, h, t), S(x, b, y, z, h, t), S(x, c, y, z, h, t))

> map(F, W, x, y, z, t, h), map2(F, W, x, y, z, t, h); ⇒ F(W, x, y, z, t, h), F(W, x, y, z, t, h)

Из данного фрагмента несложно усматривается не только общий принцип выполнения функции map2, но и ее эквивалентность map-функции на определенных наборах аргументов. И выше, и в дальнейшем обе эти функции достаточно часто используются в иллюстративных примерах, лучше раскрывая припцип своего выполнения. Нами был определен ряд новых процедур map3, map4, map5, map6, mapN, mapLS, mapTab (расширяющих возможности функций map и map2), описанных в нашей книге [103] и включенных в состав прилагаемой к ней Библиотеке [109]. Maple-язык располагает обширным набором средств для работы с множествами и списками, которые будут рассматриваться нами детальнее ниже в различных контекстах. Более того, данный набор дополнен нашими средствами работы со списочными структурами [103,109].

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

> M:= array(-10 .. 16, [k$k = 1 .. 27]): M[-7], M[-1], M[0], M[16]; ⇒ 4, 10, 11, 27

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

M := array(<Индексная функция>, <Размерность>, <Начальные значения>) где Индексная функция определяет специальный индексный атрибут (например, symmetric атрибут определяет соотношение M[n, m]=M[m, n]). Размерность задается в виде интервалов “а .. в” по каждому из индексов массива и Начальные значения задают исходные значения для элементов массива. При этом, следует иметь в виду, что Maple-язык автоматически не определяет элементы массива, поэтому сразу же после создания массива его элементы являются неопределенными, например: a:= array(1..3): print(a); ⇒ [a1, a2, a3]. Обращение к массиву производится по его идентификатору, а к его элементам в виде индексированного идентификатора, например: print(M); M[5, 6, 2]. Вывод массива на печать производится по print-функции, тогда как по функциям eval и evalm не только предоставляется возможность вывода содержимого массива, но и возврата его в качестве результата для возможности последующего использования в вычислениях. Применение данных функций проиллюстрировано ниже. Ни один из трех аргументов функции array не является обязательным, однако должен присутствовать по меньшей мере один из двух последних для возможности построения массива. Наиболее простой формат array-конструкции имеет следующий вид:

M := array(J11 .. J1n, J21 .. J2n, ..., Jm1 . .Jmn {, []| })

определяя пустой (неопределенный) М-массив mxn-размерности. Переопределение элементов M-массива производится по конструкции вида M[p, k, h, ...]:=<Выражение>, которая остается действительной и для списочных структур. В целом ряде случаев при определении массива целесообразно сразу же задавать начальные значения для его элементов полностью или частично, что иллюстрирует следующий простой фрагмент:

Как следует из приведенного фрагмента в первом примере определяется пустой G-массив с последующим прямым определением его элементов путем присваивания; в качестве разделителей предложений выбрано двоеточие, чтобы не загромождать документ выводом промежуточных результатов. Затем над полученным G-массивом производятся простые операции, о которых говорилось выше. Во втором примере определяется S-массив той же (3х3)-размерности с одновременным заданием начальных значений для всех его элементов. Результаты определения массива используются для выполнения нестандартной процедуры, использующей рассмотренные выше функции и которая может оказаться полезной в практической работе с объектами типа array. Там же иллюстрируется применение map-функции для поэлементной обработки массива. При определения начальных значений элементов непосредственно в array-конструкции они представляются в виде вложенного списка listlist-типа, структура которого должна строго соответствовать структуре определяемого массива, как это иллюстрируется фрагментом. В качестве встроенных индексных атрибутов пакет использует: symmetric, antisymmetric, sparse, diagonal, identity и ряд определяемых пакетными модулями, которые детально обсуждаются при рассмотрении матричных объектов, например, в нашей книге [12].

При этом, массив одновременно выводится и возвращается по функциям evalm и eval, тогда как по print-функции производится только вывод массива на экран. Предыдущий фрагмент иллюстрирует сказанное. Наряду с этим, примеры фрагмента иллюстрируют использование функции op для получения типа Art-объекта, индексной функции (первый аргумент array-функции), размерности массива (второй аргумент) и содержимого всех начальных значений для входов массива (третий аргумент). Иллюстрируется и применение map-функции для поэлементной обработки массива.

Ниже обсуждение структур данных array-типа будет детализироваться и рассматриваться на протяжении последующих глав книги. При этом, следует иметь в виду то обстоятельство, что частным случаем понятия массива являются векторы (одномерный массив) и матрицы (двухмерный прямоугольный массив), для обеспечения работы с которыми Maple-язык располагает достаточно развитым набором средств, прежде всего, определяемых пакетным модулем linalg, ориентированным на решение задач линейной алгебры [11-14,80-89]. Ниже этот вопрос будет рассмотрен несколько детальнее.

• Массив hfarray-типа . Для обеспечения численных вычислений на основе машинной арифметики с плавающей точкой (МАПТ) Maple-язык поддерживает новый тип структуры данных – массивы hfarray-типа, определяемые hfarray-функцией формата вида:

Mhf := hfarray({<Размерность>}{, <Начальные значения>})

где назначение формальных аргументов функции полностью аналогично случаю функции array; при этом, оба аргумента необязательны. Размерность определяется одним либо несколькими ранжированными выражениями, при ее отсутствии используется установка по умолчанию. Пределы изменения индексов по каждому измерению массива определяются используемой платформой и для 32-битной платформы находятся в диапазоне от -2147483648 до 2147483647 и для 64-битной платформы от -9223372036854775808 до 9223372036854775807.

Данные массивы составляют специальный hfarray-тип, распознаваемый тестирующими функцией type и процедурой whattype. Массивы данного типа в качестве значений своих элементов содержат числа с плавающей точкой двойной точности стандарта IEEE-754. При этом, поддерживаются три специальные значения данного стандарта: +Infinity, Infinity и Quiet NaN, последнее из которых определяется как `undefined`. Для hfarrayфункции в качестве начальных значений могут выступать любые допустимые Mapleвыражения, результатом вычисления которых являются числа float-типа, или значения undefined, infinity, -infinity. Полностью массивы hfarray-типа возвращаются и выводятся на экран соответственно по функциям eval и print. Следующий фрагмент иллюстрирует вышесказанное:

Структуры данных hfarray-типа широко используются с evalhf-функцией, поддерживающей МАПТ, и достаточно детально рассматриваются, например, в [11,12]. При этом, следует иметь в виду, что работа с такого типа массивами вне рамок МАПТ не эффективна, ибо требуется выполнение соглашений между МАПТ и Maple-арифметикой с плавающей точкой. Последний пример фрагмента иллюстрирует различия между массивами типов array и hfarray при одной и той же установке предопределенной Digits-переменной пакета. Тогда как второй пример фрагмента иллюстрирует недопустимость определения элементов hfarray-массива типами данных, отличными от extended_numericтипа (обобщение типов numeric, undefined либо infinity, -infinity). Для устранения данного недостатка используется evalf-функция.

• Таблица (table) – структура данных, весьма широко используемая Maple, прежде всего, при работе с различного рода табличными объектами. Таблица представляет собой определенное обобщение понятия двумерного массива, когда в качестве значений индексов массива могут использоваться не только целочисленные значения, но и произвольные выражения, в первую очередь, символьные и строчные значения в качестве названия строк и столбцов. Характерной чертой таблицы является возможность работы со структурами данных, включающими естественные нотации (фамилии, имена, названия и т.д.). Итак, в общем случае Т-таблица определяется конструкцией следующего простого формата:

T := table(<Индексная функция>, <Список/множество начальных значений>) где Индексная функция определяет специальный индексный атрибут (например, symmetricатрибут), аналогичный случаю массива, и второй аргумент определяет исходные значения для элементов таблицы (ее входы и выходы). Пустая таблица определяется по конструкции вида T:= table(); при этом, первый аргумент table-функции необязателен.

Второй аргумент table-функции определяется, как правило, в виде списка или множества, элементами которого могут быть как отдельные допустимые Maple-выражения, так и уравнения, т.е. конструкции вида “A=B”. Левые А-части уравнений выступают в качестве идентификаторов строк таблицы и определяют ее входы, а правые – выходы, т. е. по конструкции формата T[<Вход>] возвращается строка-выход, отвечающая указанному в качестве значения аргумента Входу. Поэтому, если T:=table([X1=Y1, X2=Y2, ...]), то T[Xk]; ⇒ Yk. Если в списке/множестве начальных значений хоть один из элементов не является уравнением, то Maple в качестве входов в таблицу использует целые неотрицательные числа (1 .. <число строк>), располагая при этом строки таблицы в определенном порядке, отличном от естественного. Это одна из причин, почему в качестве элементов второго аргумента функции table следует кодировать уравнения, т.е. это не тот случай, когда решение вопроса стоит отдавать на откуп пакету. В качестве правых В-частей уравнений списка/множества функции могут выступать произвольные Maple объекты, позволяя создавать достаточно сложные табличные структуры данных, примером чего может служить следующий весьма простой фрагмент:

> T:= table([A=[AV, 42, 64, 350], B=[42, 64, array([[RANS, IAN], [REA, RAC]])],

C=array([[{G, S}, {Kr, Ar}], [{Vasco}, {Salcombe}]])]): eval(T);

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

Обращение к таблице производится по ее идентификатору, а к ее элементам в форме индексированного идентификатора, например: Т[С]. Вывод таблицы на печать производится по функции print (применение которой проиллюстрировано выше); это же относится и к выводу ее отдельных выходов, если они не являются конструкциями базовых типов {число, строка, список, множество}. При этом, подобно массиву таблица одновременно выводится и возвращается по функции eval, тогда как к ней не применимы функции evalm и evala. Приведенный выше фрагмент иллюстрирует сказанное. Наряду с этим, примеры фрагмента иллюстрируют использование op-функции для получения типа Tab-объекта, индексной функции (первый аргумент table-функции) и содержимого всех входов таблицы. По причине отсутствия индексной функции вызов op(1, eval(Tab)) возвращает NULL-значение.

Наиболее простой формат table-функции имеет следующий вид:

T := table([X1, X2, X3, ..., Xn]) или T := table({X1, X2, X3, ..., Xn})

определяя Т-таблицу из n строк, идентифицируемых входами-числами. Переопределение элементов Т-таблицы производится по конструкциям вида: Т[<вход>]:=<Выражение>, которые работают и со списочными структурами. Для удаления из Т-таблицы выхода (соответствующего заданному входу) выполняется следующая конструкция: Т[вход]:=NULL, тогда как для удаления всех выходов произвольной Т-таблицы достаточно выполнить следующее простое Maple-предложение цикла:

for k in [<Список входов>] do T[k]:= NULL end do:

либо эквивалентное ему выражение следующего вида:

eval(parse(convert(subs(F = null, mapTab(F, T, 1)), 'string')))

где null и mapTab – процедуры из Библиотеки, описание которых находится в [103]:

> Tab[Grodno]:= 1962: Tab[Tartu]:= 1966: Tab[Tallinn]:= 1999: Tab[Gomel]:= 1995: Tab[Moscow]:= 2006: eval(parse(convert(subs(F = null, mapTab(F, Tab, 1)), 'string'))); table([Tartu = (), Tallinn = (), Gomel = (), Moscow = (), Grodno = ()])

При работе с массивами и таблицами наиболее часто используемыми являются две функции indices и entries, имеющие следующий простой формат кодирования; {indices|entries}(T), где Т – массив или таблица

и возвращающие индексы/входы и соответствующие им элементы/выходы массива/таблицы Т соответственно, как это иллюстрирует следующий простой фрагмент:

> Tab[Grodno]:= 1962: Tab[Tartu]:= 1966: Tab[Tallinn]:= 1999: Tab[Gomel]:= 1995:

Tab[Moscow]:= 2006: indices(Tab), entries(Tab);

[Tartu], [Tallinn], [Gomel], [Moscow], [Grodno], [1966], [1999], [1995], [2006], [1962]

> A:= array([[a, b, h], [c, d, k], [x, y, z]]): indices(A), entries(A);

[1, 1], [2, 2], [2, 3], [2, 1], [3, 1], [3, 2], [1, 2], [1, 3], [3, 3], [a], [d], [k], [c], [x], [y], [b], [h], [z]

> with(Tab); eval(%);

[Gomel, Grodno, Moscow, Tallinn, Tartu]

[1995, 1962, 2006, 1999, 1966]

> Tab1[1942]:= 1962: Tab1[2006]:= 1966: type(Tab1, 'table'); with(Tab1); ⇒ true Error, (in pacman:-pexports) invalid arguments to sort

> map(op, [indices(Tab)]), map(op, [entries(Tab)]);

[Tartu, Tallinn, Gomel, Moscow, Grodno], [1966, 1999, 1995, 2006, 1962]

В частности, последний пример фрагмента представляет конструкции, полезные при работе, прежде всего, с таблицами, и позволяющие представлять их входы и выходы в виде списка. Во фрагменте (пример 3) проиллюстрировано также использование процедуры with (применяемой, как правило, лишь с пакетными и программными модулями) для получения списка входов таблицы. При этом, следует учитывать, что если в качестве входов Т-таблицы выступают значения {symbol|name}-типа, то по выхову with(T) возвращается их отсортированный лексикографически список, в противном случае возникает ошибочная ситуация, как это иллюстрирует пример 4 предыдущего фрагмента.

Имея многочисленные приложения, табличные структуры используются и для организации пакетных и/или библиотечных модулей. Такой подход особенно широко использовался в ранних релизах пакета и об этом детальнее будет сказано ниже. Представим здесь один простой пример такого подхода. В этом случае входами таблицы Т являются имена процедур, а ее выходами – соответствующие им определения. Тогда вызов таким образом погруженных в табличную структуру процедур принимают следующий простой вид, а именно: Т[имя](Аргументы). Следующий фрагмент иллюстрирует сказанное:

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

Относительно структур типа массив (array) и таблица (table) следует сделать одно существенное пояснение. Все используемые Maple структуры, кроме этих двух, обладают свойством ненаследования, т.е. для них справедливы следующие соотношения:

X:= a: Y:= X: Y:= b: [X, Y]; ⇒ [a, b]

т.е. присвоение X-значения Y-значению с последующим переопределением второго не изменяет исходного X-значения. В случае же структур типа массив и таблица это вполне естественное свойство не соблюдается. Поэтому Maple-язык располагает специальной процедурой copy(<Массив/Таблица>), позволяющей создавать копии указанного массива/таблицы, модификация которой не затрагивает самого оригинала. Следующий весьма простой фрагмент иллюстрирует вышесказанное:

> X:= a: Y:= X: Y:= b: [X, Y]; ⇒ [a, b]

> A:= array(1..5, [42, 47, 67, 88, 96]); ⇒ A := [42, 47, 67, 88, 96]

> C:= copy(A); ⇒ C := [42, 47, 67, 88, 96]

> C[3]:= 39: C[5]:= 10: [A[3], A[5]]; ⇒ [67, 96]

> B:= A: B[3]:= 95: B[5]:= 99: [A[3], A[5]]; ⇒ [95, 99]

Создание по copy-процедуре копий объектов указанных двух типов позволяет модифицировать только их копии без изменения самих объектов-оригиналов.

В качестве встроенных индексных атрибутов Maple для table-функции используются: sparse, symmetric, antisymmetric, diagonal и identity (а также определяемые пакетными модулями), детальнее обсуждаемые при рассмотрении матричных объектов. Обсуждение tableтипа структуры данных будет постоянно детализироваться и многоаспектно рассматриваться на протяжении последующих глав книги. Целый ряд полезных средств для работы с табличными объектами представляет и наша Библиотека, прилагаемая к книге [103] и находящаяся в свободном доступе по адресам [109].

В завершение рассмотрения структур данных, поддерживаемых пакетом, будет вполне уместно представить и связанные с объектами array-типа, уже упоминаемые матрицы и векторы. Матрицы являются весьма широко применимым понятием в целом ряде естественно-научных дисциплин, составляя самостоятельный объект исследования современной математики – теорию матриц, выходящую за рамки традиционного университетского курса высшей алгебры. Основу теории матриц составляет алгебра квадратных матриц, для обеспечения которой Maple-язык располагает целым рядом важных и полезных средств, поддерживаемых функциональными средствами – модулей LinearAlgebra и linalg. Данные модули содержат определения 118 и 114 процедур соответственно (в зависимости от релиза пакета; пример приведен для Maple 10), обеспечивающих расширенные средства линейной алгебры по работе с матричными и векторными выражениями. Данные средства не входят в задачу настоящей книги, акцентирующей внимание на вопросах собственно программирования в Maple, поэтому здесь мы лишь представим основные структуры, с которыми имеют дело средства линейной алгебры пакета, а именно: матрицы (matrix) и векторы (vector).

• Матрицы (matrix); в среде Maple-языка матрица представляется в виде 2D-массива, нумерация строк и столбцов которого производится, начиная с единицы. Матрица определяется либо явно через рассмотренную выше array-функцию, например M:= array(1..n, 1..p), или посредством процедуры matrix, имеющей следующие два простых формата кодирования, а именно:

matrix(L) и matrix(n, p, {L|Fn|Lv})

где L – вложенный список (listlist) векторов элементов матрицы, n и p – число ее строк и столбцов, Fn – функция генерации элементов матрицы и Lv – список или вектор элементов матрицы. Функция Fn генерации элементов матрицы определяется в форме пользовательских функции или процедуры, например Fn:=(k,j) -> Ф(k,j), такой, что M[k,j]:= Fn(k,j). Процедура randmatrix модуля linalg позволяет стохастически генерировать матрицы (mxn)-размерности, что удобно, например, для различного рода отладок и тестов.

По тестирующей функции type(M, {matrix|'matrix'(K{, square})}) возвращается true-значение, если М-выражение является матрицей; при этом допускается проверка на принадлежность значений ее элементов заданной К-области и/или квадратности (square) матрицы. В противном случае возвращается false-значение. Так как матрица является одним из типов более общего понятия массив, то функция type(M, 'array') также возвращает true-значение, если М - матрица. Обратное же в общем случае неверно, например, в случае одномерных массивов-векторов. По функции convert(L, 'matrix') возвращается матрица, если L - соответствующая ей вложенная списочная структура. С другой стороны, по функции convert(M, 'multiset') производится конвертация матричной структуры в структуру вложенных списков, каждый элемент-список которой содержит три элемента, где первые два определяют координаты элемента матрицы, а третий – его значение. Следующий фрагмент иллюстрирует вышесказанное.

Следует отметить, что функция convert(M, 'multiset') имеет более широкое применение, допуская в качестве своего первого фактического М-аргумента любое Maple-выражение (при этом, трактовка составляющих возвращаемого ею вложенного списка весьма существенно зависит от типа М-выражения), однако наибольший смысл она имеет для М-выражений типа массив или содержащих термы-множители. Не отвлекаясь на частности, рекомендуем читателю определить влияние типа М-выражения на семантику возвращаемого функцией вложенного списка, тем более, что в ряде случаев это может оказаться весьма полезным приемом в практическом программировании.

Обращение к элементам М-матрицы производится по индексированной M[k, j]-конструкции, идентифицирующей ее (k, j)-й элемент. Посредством этой конструкции элементам М-матрицы можно как присваивать значения, так и использовать их в вычислениях в качестве обычных переменных. Следовательно, данная индексированная конструкция обеспечивает адресное обращение к элементам М-матрицы. Совместное использование функций map и F-функции/процедуры позволяет применять последнюю одновременно ко всем элементам М-матрицы, не идентифицируя их отдельно, т.е. имеет место следующее определяющее соотношение: map(F, M {, <опции>}) ≡ ∀(k)∀(j) (M[k, j] := F(M[k, j] {, <опции>}))

Например:

> M:= matrix(3, 3, [x, y, z, a, b, c, V, G, S]): map(F, M, Art, Kr, Arn);

FFF(((V Art Kr Arna Art Kr Arnx,,, Art,,,Kr,,,Arn))) FFF(((G Art Kr Arnb Art Kr Arny,,,Art,,,Kr,,,Arn))) FFF(((S Art Kr Arnc Art Kr Arnz,,,Art,,, Kr,,, Arn)))



В целом же М-матрица рассматривается как единый объект и для его вывода или возвращения в матричной нотации можно использовать соответствено функции print и {op|evalm}. Однако на основе адресного подхода обработку матриц можно производить и рассмотренными функциональными средствами, ориентированными на сугубо скалярные аргументы. В частности, по конструкции numboccur(eval(M), <Элемент>) можно тестировать наличие в указанной M-матрице заданного элемента. Позволяет это делать и наша процедура belong [103,109].

С другой стороны, целый ряд процедур позволяют обрабатывать М-матрицу как единый объект; такие функции будем называть матричными, т.е. в качестве одного из ведущих аргументов их выступает идентификатор матрицы. Язык Maple располагает достаточно обширным набором матричных процедур, характеристика которых весьма детально рассмотрена в книгах [8-14,55-60,86-88] с той или иной степенью охвата и в полном объеме в справке по пакету. Лишь некоторые из них будут рассмотрены ниже. По функции evalm(VM) возвращается результат вычисленим VM-выражения, содержащего матрицы, применяя функциональные map-преобразования над матрицами. Однако, применение evalm-функции требует особой осмотрительности, ибо Maple-язык перед передачей фактических аргументов evalm-функции может производить их упрощения (предварительные вычисления), в ряде случаев приводящие к некорректным с точки зрения матричной алгебры результатам. Например, по evalm(diff(M, x)) возвращается нулевое значение, тогда как предполагается результат дифференцирования М-матрицы. Это связано с тем обстоятельством, что отличные от матричных функции воспринимают идентификатор матрицы неопределенным. В VM-выражении все неопределенные идентификаторы полагаются evalm-функцией в зависимости от их использования символьными матрицами либо скалярами. В суммах, содержащих матрицы, все скалярные константы рассматриваются умноженными на единичную матрицу, что позволяет естественным образом определять матричные полиномы. Так как операция произведения матриц некоммутативна, то для нее следует использовать матричный (&*)-оператор произведения, приоритет которого идентичен приоритету (*)-оператора скалярного произведения. В качестве операндов бинарного матричного (&*)-оператора могут выступать матрицы либо их идентификаторы. Следующий фрагмент иллюстрирует способы определения, тестирования и вычисления матричных выражений:

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

• Векторы (vector); в среде Maple-языка вектор представляется в виде 1D-массива, нумерация строк и столбцов которого производится, начиная с единицы. Вектор определяется либо явно через рассмотренную выше array-функцию, например V:= array(1..n), или посредством процедуры vector, имеющей следующие два простых формата:

vector([X1, X2, ..., Xn]) и vector(n, { |Fn|[X1, X2, ..., Xn]})

где Xk - элементы вектора, n - число его элементов и Fn - функция генерации элементов вектора аналогично случаю определения матриц. По тестирующей же функции type(V, {'vector'(K)| vector}) возвращается значение true, если V-выражение является вектором; при этом, допускается проверка на принадлежность значений его элементов заданной К-области. В противном случае функцией возвращается false-значение. Так как вектор является одним из типов общего понятия массив, то функция type(V, 'array') также возвращает true-значение, если V – вектор. Обратное в общем случае неверно, например, в случае списка. По convert(L, 'vector')-функции возвращается вектор, если L – соответствующая ему списочная структура.

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

> v:=vector(3,[]): m:=matrix(3,3,[]): a:= array(1..2,1..3,[]): map(whattype, map(eval, [v,m,a]));

[array, array, array]

> map(type, [v,m,a], 'array'), map(type, [v,m,a], 'vector'), map(type, [v,m,a], 'matrix');

[true, true, true], [true, false, false], [false, true, true]

Так, если процедура whattype отождествляет все типы {array, matrix, vector} как обобщающий array-тип, то функция type обеспечивает более дифференцированное тестирование, хотя и в этом случае типы array и matrix ею не различаются. Предыдущий фрагмент хорошо иллюстрирует сказанное.

• Основные характеристики матриц и векторов. Прежде всего, среди класса матричных объектов выделим квадратные (square) матрицы, которые будут основным объектом нашего рассмотрения и для работы с которыми Maple-язык располагает довольно широким набором функциональных средств. Поэтому, если не оговаривается противного, то под понятием «матрица» в дальнейшем понимается именно квадратная матрица. Для работы с такого типа матрицами Maple располагает большим набором средств, находящихся в пакетных модулях linalg и LinearAlgebra.

Прежде всего, по функции indices(M) возвращается последовательность 2-элементных списков, определяющих индексное простанство М-матрицы, а по функции entries(M) – последовательность 1-элементных списков, содержащих значения элементов М-матрицы. В случае использования в качестве М-аргумента таблицы функция {indices|entries} возвращает соответственно ее входы и выходы. При этом, следует иметь в виду, что в случае матриц обе функции возвращают последовательности списков, имеющих внутреннее взаимно-однозначное соответствие (при отсутствии оного в их выходных порядках), не управляемых пользователем. Вместе с тем, на основе несложной Pind-процедуры [103], в качестве единственного фактического аргумента использующей выражение типа {array, matrix, table}, можно получать (nxp)-размерность произвольной М-матрицы в виде [n, p]списка, как это иллюстрирует следующий весьма простой фрагмент:

Во фрагменте иллюстрируется определение М-матрицы на основе matrix-функции с использованием Fn-функции генерации элементов матрицы. Представлено применение Pind-процедуры для определения размерности матриц. Процедура Mem1(M, h) возвращает последовательность, первый элемент которой определяет число вхождений в Mматрицу элементов, заданных вторым h-аргументом функции, а последующие определяют списки-координаты искомых элементов. В нашей Библиотеке [103] представлен целый ряд других полезных процедур для работы с матрицами. Можно определять целый ряд других полезных процедур как на основе представленных, так и других функций Maple-языка, что оставляется читателю в качестве весьма полезного практического упражнения. В реальной работе с пакетом это вполне возможные ситуации.

Как таблица, так и общая функция array({<ИФ>}{, <Размерность>}{, <НЗ>}) допускает 3 необязательных ключевых аргумента: ИФ – индексная функция, размерность, кодируемая в виде диапазонов (..) изменения значений индексов, и НЗ – список начальных значений для определения элементов массива. Два последних из них достаточно просты и неоднократно обсуждались при рассмотрении массивов и таблиц. Несколько детальнее остановимся на индексной функции, имеющей для матриц особое значение, определяя общего уровня их классификацию. В общем случае индексная функция определяет правило присваивания значений элементам массива или таблицы, или их обработки. При отсутствия ИФ-аргумента используется стандартный метод индексации элементов массива (матрицы). Индексная функция может определяться пользовательской процедурой, принцип организации которой здесь не рассматривается, но общий подход был указан выше. Для этих целей может использоваться, например, процедура indexfunc пакетного модуля linalg. Язык Maple располагает пятью основными встроенными ИФ с идентификаторами symmetric, antisymmetric, sparse, diagonal и identity для функций table и array. Мы рассмотрим вкратце данные индексные функции.

Индексная symmetric-функция применима в качестве первого фактического аргумента для определения симметричности элементов матрицы/таблицы относительно ее главной диагонали, т.е. для М-матрицы предполагается определяющее соотношение M[k,j] = M[j, k]. В свою, очередь antisymetric-аргумент определяет М-матрицу с соотношением M[k, j] = -M[j, k], следовательно ∀(k)∀(j)(k=j)(M[k, j]=0). Если же при определении такого типа матрицы были заданы ненулевые начальные значения для ее диагональных элементов, то они получают нулевые значения с выводом соответствующей диагностики. Аргумент diagonal определяет диагональную М-матрицу, для которой справедливо соотношение ∀(k)∀(j)(k≠j)(M[k, j]=0). Посредством sparse-аргумента определяется М-матрица, чьи неопределенные входы получают нулевые значения. Например, по вызову array(sparse, 1..n, 1..p) возвращается нулевая матрица (nxp)-размерности. Наконец, по identity-аргументу возвращается единичная матрица, для которой имеет место соотношение ∀(k)∀(j)[(k=j) → (M[k, j] = 1)] & [(k≠j) → (M[k,j] = 0)]. Следующий пример иллюстрирует получение рассмотренных выше пяти типов матриц:

> MS:=array(symmetric, 1..3, 1..3): MS[1, 1]:=10: MS[1, 2]:=17: MS[1, 3]:=39: MS[2, 2]:=64:

MS[2, 3]:=59: MS[3, 3]:=99: MD:=array(diagonal, 1..3, 1..3): MD[1, 1]:=2: MD[2, 2]:=10:

MD[3, 3]:=32: MAS:= array(antisymmetric, 1..3, 1..3): MAS[1, 2]:=10: MAS[1, 3]:=32:

MAS[2, 3]:=52: MI:= array(identity, 1..3, 1..3): MSp:=array(sparse, 1..3, 1..3): map(evalm,

[MS, MAS, MD, MI, MSp]);

_ _ 39 59 99_ , _ ^ -10-32⁰ -52¹⁰ 0 52³² 0_ ^ , _ ^ ² 00 100⁰ 320⁰ _ ^ , _ ^ ¹ 00 10⁰ 10⁰ _ ^ , _ ^ ^ ⁰ 00 00⁰ 00⁰ _ ^ ^ _ ^  ^ ^ ^{ 10} 17 64¹⁷ 59³⁹ ^



Так как вектор представляет собой (1xn)-матрицу, то к нему применим и целый ряд сугубо матричных функций, например evalm-функция, позволяющая возвращать вычисленные векторные выражения в векторной (списочной) нотации. Более того, все имеющее силу относительно матриц в полной мере (с поправкой на размерность) относится и к векторам. В частности, это относится и к (&*)-оператору матрично/векторного произведения. Длину V-вектора, подобно случаю матриц, можно вычислять, в частности, посредством конструкции вида nops([{indices|entries}(V)]); при этом, нулевое значение возвращается, если элементам V-вектора не присваивалось значений. Следующий простой фрагмент иллюстрирует некоторые способы определения, тестирования и вычисления простых векторных выражений в среде Maple-языка:

> V1:= array(1..9): V2:= array(1..6, [64, 59, 39, 10, 17, 44]): V3:= vector(5, [42, 47, 67, 89, 96]): V4:= vector(5, [64, 59, 39, 17, 10]): Fn:= k -> 3*k^2 + 10*k + 99: V5:= vector(5, Fn):

V6:= vector(6, [V, G, S, Art, Kr, Ar]): map(type, [V1, V2, V3, V4, V5, V6], 'vector');

[true, true, true, true, true, true]

> map(evalm, {V5, V6}); ⇒ {[112, 131, 156, 187, 224], [V, G, S, Art, Kr, Ar]}

> map(nops, [[indices(V6)], [entries(V6)]]); ⇒ [6, 6]

> V:=vector(6, []): map(nops, [[indices(V)], [entries(V)]]); ⇒ [0, 0]

> [type(V4, 'vector'(integer)), type(V6, 'vector'(symbol))]; ⇒ [true, true]

> Z:= vector([W, G, S]): M:= array(1..3, 1..3, [[1, 2, 3], [4, 5, 6], [7, 8, 10]]): evalm(M&*Z);

[W + 2 G + 3 S, 4 W + 5 G + 6 S, 7 W + 8 G + 10 S]

Для обеспечения работы с матричными и векторными выражениями Maple-язык располагает довольно развитым набором функциональных средств, поддерживаемых, в первую очередь, пакетными модулями linalg и LinearAlgebra. Данные модули содержат определения 114 и 118 процедур соответственно (в зависимости от релиза пакета; пример приведен для Maple 10), обеспечивающих расширенные средства линейной алгебры по работе с матричными и векторными выражениями. Учитывая обилие указанных средств и направленность данной книги, мы не будем акцентировать на них внимания, отсылая к нашей книге [12] либо к ее авторскому оригинал-макету, который можно загрузить с университетского Web-сайта www.grsu.by/cgi-bin/lib/lib.cgi?menu=links&path=sites. В них рассмотрены средства пакета, составляющие определенную базу для обеспечения работы с матрично/векторными выражениями в рамках классической линейной алгебры. Лишь кратко определим способы доступа к таким модульным средствам пакета.

Ряд средств линейной алгебры имеют классический формат вызова вида Id(<аргументы>), тогда как основная масса таких средств определяется пакетным модулем linalg. Поэтому первый вызов любого из них должен предваряться предложением одного из следующих трех форматов, а именно: with(linalg), with(linalg, <Процедура_1>, <Процедура_2>, <Процедура_3>, ...) или linalg[<Процедура>](<аргументы>). Исходя из обстоятельств, пользователь будет производить вызов процедур linalg-модуля необходимым ему способом. Первый формат обеспечивает доступ сразу ко всем процедурам модуля, но их загрузка требует дополнительной памяти в рабочей области пакета, второй формат активирует определения конкретных процедур, используемых в текущем сеансе, и третий формат определяет разовый вызов конкретной процедуры на конкретных фактических аргументах. Последний формат часто используется в пользовательских процедурах. Вызов процедуры packages() возвращает список пакетных модулей, загруженных в текущий сеанс. Вышесказанное иллюстрирует следующий простой пример:

> restart; packages(), map(type, [col, det], 'procedure'); ⇒ [], [false, false] > with(linalg, col, det), packages(), map(type, [col, det], 'procedure');

[col, det], [linalg], [true, true]

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

С учетом сказанного, средства модуля linalg не представляют каких-либо затруднений при использовании их знакомым с основами линейной алгебры читателем, а приведенные здесь и в прилож. 1 [12] примеры и дополнительные замечания вполне достаточно иллюстрируют средства матричной алгебры, поддерживаемые Maple-языком. Наряду с наиболее общими linalg-модуль располагает целым рядом других, более специальных, матричных средств, включая средства создания специального типа матриц (Вандермонда, Теплица, Сильвестра и др.), в полном же объеме со средствами матричной алгебры, обеспечиваемыми Maple-языком, рекомендуется ознакомиться по книгам [10-14,59,80,86,90].

• Базовые структуры данных модуля LinearAlgebra . Одну из самых больших особенностей Maple составляет его модуль LinearAlgebra, определяющий новые стандарты эффективности, надежности, полезных свойств и точности для вычислительной линейной алгебры. Данная задача была решена путем интегрирования в пакет современных программ линейной алгебры фирмы NAG (Numerical Algorithm Group) через внешний механизм вызовов [13,14,39]. Это позволяет использовать мощные вычислительные алгоритмы NAG для решения задач линейной алгебры с высокими точностью и производительностью. Однако, прежде, чем переходить к характеристике средств LinearAlgebraмодуля, кратко остановимся на различиях между ним и рассмотренным выше linalg-модулем линейной алгебры.

Если в основе векторно-матричных объектов, с которыми оперирует модуль linalg, лежит структура данных array-типа, то основу объектов, обрабатываемых средствами модуля LinearAlgebra, составляет так называемая rtable-структура данных, генерируемая одноименной встроенной функцией. Данная функция и генерируемые ею rtable-объекты детально были нами рассмотрены в [13,14,39]; ряд новых средств по работе с такого типа объектами как отдельно, так и в совокупности с array-объектами представлен нами в книгах [39,41,42,45,46,103], а также в нашей Библиотеке [103,109].

Визуализация rtable-объекта (Array, Matrix, Vector) определяется его размером. Если размер его меньше или равен значению, определенному предопределенной rtablesize-переменной процедуры interface (по умолчанию rtablesize=10), то объект визуализируется полностью. В противном случае он заменяется специальным шаблоном. Установка опции rtablesize=0 определяет вывод любого rtable-объекта в виде шаблона, тогда как установка rtablesize=infinity определяет вывод rtable-объекта полностью безотносительно его размера, как иллюстрирует следующий фрагмент:

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

Для работы с rtable-объектами пакет располагает рядом полезных функций и процедур, детально рассмотренных в [45,46]. Данные средства применимы к любому rtable-объекту (Array, Matrix, Vector), однако каждый из трех типов объектов располагает и собственными аналогичными средствами, кратко рассматриваемыми ниже. Для вывода rtable-объектов можно использовать и форматирующие функции printf-группы: printf, fprintf, sprintf, nprintf, с опциями которых для этого случая можно ознакомиться по справке пакета. Аналогично этому к любому rtable-объекту применимы и функции scanf-группы (scanf, fscanf, sscanf) для выполнения синтаксического анализа объектов.

• Объекты rtable-типа . На основе упомянутой rtable-функции определяются три базовых объекта LinearAlgebra-модуля: Array, Matrix и Vector. Непосредственно посредством rtable-функции в среде пакета можно определять любой из указанных трех объектов. После их создания с ними можно работать в рамках алгебры, определяемой операциями, довольно детально рассмотренными в книгах [39,41,42,45,46,103]. Приведем простой фрагмент, иллюстрирующий использование операций rtable-алгебры пакета.

С учетом сказанного, примеры фрагмента особых пояснений не требуют. В этой связи имеет смысл лишь вкратце пояснить различие между табличной организацией собственно Maple-среды (базируется на table-функции) и NAG-организацией (базируется на функции rtable). В первом случае массивы и таблицы базируются на внутренних хэш-таблицах пакета, тогда как во втором случае используется формат импортированного NAG-модуля линейной алгебры. В этом случае для каждого измерения rtable-объекта используется по одному вектору индексов и отдельный вектор отводится под значения элементов массива. На основе такого представления формируются такие структуры данных как Array, Matrix, Vector[row] и Vector[column]. Более того, следует иметь в виду, что одноименные рассмотренным структуры array, matrix и vector, начинающиеся со строчных букв (исключение составляют пассивные функции), относятся к средствам собственно Maple-языка и их обработка производится иными средствами, детально рассмотренными в цитируемых выше книгах. При этом, следует отметить, что функции на основе rtable-функции принципиально отличаются от одноименных функций array, matrix и vector, как отмечалось выше.

• Базовые объекты модуля LinearAlgebra . В качестве таких объектов выступают Array, Matrix, Vector[row] и Vector[column], кратко рассмотренные выше в связи с rtable-функцией, на основе которой они формируются. Между тем, пользователь имеет возможность непосредственно создавать указанные объекты на основе встроенных функции Array и процедур Matrix или Vector, кратко рассматриваемых ниже.

По функции Array(ИФ, D, НЗ, <Опции>) создается массив с заданными характеристиками, определяемыми ее фактическими аргументами. Каждый из аргументов функции не является обязательным; если же вызов функции Array определен без фактических аргументов, то возвращается пустой 0-мерный массив. Смысл и форматы кодирования аргументов функции (ИФ - индексирующая функция, D - размерность, НЗ - начальные условия и <Опции>) довольно прозрачны и особых пояснений не требуют. Поэтому на данном вопросе детальнее останавливаться не будем, а приведем несколько примеров на прямое определение массивов Array-типа.

> ArrayDims(B), ArrayNumDims(B); ⇒ 1 .. 3, 1 .. 3, 2

> ArrayElems(B);

{(1, 1) = 42, (1, 2) = 64, (1, 3) = 47, (2, 2) = 59, (2, 3) = 39, (3, 3) = 67}

> ArrayNumElems(B, NonZeroStored), ArrayNumElems(B, All); ⇒ 6, 9

Относительно сугубо Maple-объектов NAG-объекты характеризуются двумя важными чертами, а именно: (1) ссылка на их идентификатор возвращает непосредственно сам объект, не требуя таких функций как evalm, и (2) объекты создаются всегда с определенными элементами, по меньшей мере нулевыми, если не было определено противного. Второе обстоятельство весьма упрощает ряд процедур с такими объектами, не требуя их предварительного обнуления. Обусловлено это тем, что если Maple-объекты изначально ориентированы на символьные вычисления, то NAG-объекты на числовые.

Для работы с Array-объектами Maple-язык располагает рядом полезных функций, детально рассмотренных в наших книгах [13,14,29,30,33]. Примеры предыдущего фрагмента иллюстрируют создание посредством Array-функции одномерного А-массива и двумерного В-массива, а также применение к ним ряда функций работы с массивами, которые ввиду их простоты не требуют дополнительных пояснений.

Вызов процедуры Matrix(n, m, НЗ, <Опции>) возвращает матричную структуру данных (матрицу), являющуюся одной из базовых структур, с которыми работают функциональные средства LinearAlgebra-модуля. Первые два формальных аргумента процедуры определяют число строк и столбцов матрицы соответственно; при этом, фактические значения для аргументов могут кодироваться или целыми неотрицательными числами, или диапазонами вида 1 .. h (h – целое неотрицательное). Третий аргумент определяет начальные значения, тогда как опции - дополнительные характеристики создаваемого матричного объекта. Все аргументы процедуры необязательны и при их отсутствии возвращается матрица (0х0)-размерности. В общем же случае при создании матричного объекта вызов Matrix-процедуры должен содержать достаточное количество информации о его структуре и элементах. Сказанное по начальным значениям относительно rtable-функции в полной мере переносится и на третий аргумент Matrix-процедуры. Среди допустимых опций (четвертый аргумент) многие аналогичны общему случаю rtable-функции, рассмотренной выше. Однако, среди них имеются и специфические для матричной структуры. Детальнее с описанием опций функции можно ознакомиться по справке пакета. Приведем примеры на создание некоторых простых матричных объектов и их тестирование.

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

M := <M11, M21, M31>|<M12, M22, M32>|<M13, M23, M33>

недостатком которой является невозможность указания для матрицы в точке определения других ее характеристик. Более того, последний пример фрагмента иллюстрирует тот факт, что type-функция не распознает Matrix-объект в качестве Maple-матрицы, тогда как тестирующая whattype-процедура определяет его как Matrix-объект. Детальнее с описанием и применением функции Matrix можно ознакомиться в книгах [13,14,42] и в справке по пакету. С учетом сказанного Matrix-объекты (NAG-матрицы) довольно прозрачны, но за более подробной информацией по их определению можно обращаться к справке по пакету (например, оперативно по конструкции ?Matrix).

Наконец, по функции Vector[T](n,НЗ, <Опции>) возвращается векторная структура данных (вектор), являющаяся одной из основных структур, с которыми работают функциональные средства LinearAlgebra-модуля пакета. Индекс Т определяет сам тип вектора (column – столбец, row – строка, по умолчанию полагается column). Первый формальный аргумент функции определяет число элементов вектора; при этом, фактические значения для аргумента могут кодироваться или целым неотрицательным числом, либо диапазоном вида 1..h. Второй аргумент определяет начальные значения, тогда как опции – дополнительные характеристики создаваемого векторного объекта. Все аргументы функции необязательны и при их отсутствии возвращается вектор 0-размерности, т.е. элемент 0-мерного векторного пространства. В общем же случае при создании векторного объекта вызов Vector-функции должен содержать достаточное количество информации о его структуре и элементах. Сказанное выше по начальным значениям относительно rtable-функции в полной мере переносится и на второй аргумент Vector-функции. Среди допустимых опций (третий аргумент) многие аналогичны общему случаю rtable-функции, рассмотренной выше. Однако допускаемые ими значения имеют векторную специфику. Детальнее с описанием опций Vector-функции можно познакомиться в справке по пакету. Приведем простые примеры на создание векторных объектов.

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

V := <V1, V2, V3, …, Vn> или V := <V1|V2|V3| … |Vn>

недостатком которых является невозможность задания для вектора в точке его определения других характеристик. При этом, первый формат определяет вектор-столбец, тогда как второй – вектор-строку. Более того, последний пример фрагмента иллюстрирует тот факт, что type-функция не распознает Vector-объект в качестве Maple-вектора, тогда как тестирующая whattype-процедура определяет его как Vector-объект. С учетом сказанного Vector-типа объекты (NAG-векторы) довольно прозрачны и за более детальной информацией по их определению можно обращаться к справке (например, оперативно по конструкции ?Vector).

Как уже отмечалось выше, между Maple-объектами (array, vector и matrix) и NAG-объектами (Array, Vector и Matrix) имеются принципиальные различия. Более того, классификация вторых относительно тестирующих функции type и процедуры whattype выгодно отличается однозначностью, тогда как первые распознаются whattype-процедурой как объекты array-типа. В приведенном ниже фрагменте этот момент иллюстрируется весьма наглядно:

В целом ряде случаев точная идентификация rtable-объектов тестирующими средствами пакета играет весьма существенную роль. Еще на одном моменте данного фрагмента имеет смысл обратить внимание, а именно. Если 2-мерный Maple-массив (array) не допускает возможности замены своих строк путем присвоения, инициируя ошибочную ситуацию, то массив NAG (Array) такую операцию допускает, однако присваиваемое значение дублируется по числу элементов строки. Соответствующим образом это обобщается и на n-мерные массивы, как показано выше. В ряде случаев это может представить практический интерес при программировании ряда приложений в среде пакета.

Вместе с тем, Maple-объекты существенно проще NAG-объектов и несложно конвертируются во вторые. В наших книгах [29,33,42,43,103] и приложенной к ним Библиотеке представлены дополнительные средства конвертации Maple-объектов в NAG-объекты, и наоборот. Наряду с ними, представлен ряд других средств по работе с rtable-объектами, которые существенно расширяют стандартные средства пакета. Эти средства оказываются достаточно полезными при продвинутом программировании разнообразных задач, имеющих дело с rtable-объектами, обеспечивая Maple-программиста целым рядом дополнительных возможностей. Так, например, вызов представленной выше процедуры rtabobj() возвращает трехэлементную последовательность вложенных (в общем случае) списков, где элементы данной последовательности представляют информацию о rtable-объектах в разрезах типов Array, Matrix и Vector соответственно, активных в текущем сеансе. При этом, каждый подсписок первым элементом в строчном формате определяет имя rtable-объекта соответствующего типа, тогда как остальные его элементы определяют в строчном формате соответствующие ему идентификационные номера вида «RTABLE_SAVE/nnnnnnnn». Более детальный анализ данной информации позволяет, например, прослеживать историю работы с rtable-объектами текущего сеанса [42,103].

Процедура MwsRtb(F) анализирует mws-файл F на наличие в нем rtable-объектов [103].

При наличии таких объектов возвращаются их вызовы в строчном формате, иначе возвращается NULL-значение. Через необязательный второй аргумент возвращаются идентификационные номера (rtable-индексы) rtable-объектов, находящихся в файле F.

Весьма детальный обзор функциональных средств модуля LinearAlgebra, его базовые структуры данных, средства их создания и алгебра над ними детально рассмотрены в вышеупомянутых книгах [13,14,29,30,33]. Пакетный модуль LinearAlgebra предназначен как для интерактиного режима использования, так и для эффективного программирования в Maple. Для этого пакет прикладных программ линейной алгебры фирмы NAG был имплантирован в среду пакета Maple как программный модуль. Данная организация позволяет обращаться к его средствам следующими двумя способами, а именно:

(1) как к стандартному модулю пакета по конструкции формата: LinearAlgebra[Функция](Аргументы) (2) как к программному модулю по конструкции формата:

LinearAlgebra:- Функция(Аргументы)

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

Начиная с 6-го релиза, пакет Maple предоставляет два альтернативных выбора при решении задач линейной алгебры, базирующихся соответственно на модулях LinearAlgebra и linalg. Средства первого модуля и его концепция были довольно детально рассмотрены в наших книгах [8-14], тогда как второго в книгах [29-33]. Отметим здесь только наиболее характерные отличительные черты модуля LinearAlgebra. Прежде всего, модуль LinearAlgebra представляет собой большой набор процедур линейной алгебры, покрывающих почти все функциональные возможности пакета linalg. Вместе с тем, он имеет значительно более четкие структуры данных, располагает дополнительными средствами для создания специальных типов матриц, и улучшенными возможностями для решения матричных задач. Его преимущества особенно наглядны при вычислениях с большими числовыми матрицами, элементами которых являются значения float-типа (как данные пакетной float-арифметики, так и данные машинной float-арифметики). В качестве иллюстрации представим ряд примеров использования средств модуля LinearAlgebra для решения некоторых массовых задач линейной алгебры:

Прежде всего, следует обратить внимание на одно важное обстоятельство. С целью устранения неудобства, связанного с многократным использованием довольно длинного имени модуля LinearAlgebra, ему был присвоен алиас "LA", однако этот довольно удобный подход выявил ряд его особенностей. Прежде всего, алиас нельзя использовать в конструкциях вида LA:- Функция, как это хорошо иллюстрирует третий пример фрагмента. В этом случае следует использовать конструкцию LA[Функция]. Общей рекомендацией является определение алиаса для имени модуля вне тела процедуры/функции, в таком случае он может использоваться наравне с основным именем. Второй пример фрагмента иллюстрирует решение системы линейных уравнений посредством 2-х процедур LinearSolve и LeastSquares модуля. Посредством Transpose-процедуры результат решения системы линейных уравнений A.X = B по-лучаем в виде вектора-строки. Последующие примеры фрагмента иллюстрируют применение различных процедур пакетного модуля LinearAlgebra. Исключение составляют последние примеры 1 и 2, иллюстрирующие принципиальное отличие модуля linalg от LinearAlgebra относительно их использования внутри определений функций/процедур. В примере (2) показано, что использование вызова with(linalg) внутри тела функции делает доступными процедуры мо- дуля linalg как в области определения самой функции, так и вне ее. Тогда как согласно примера (1) аналогичный подход, но на основе модуля LinearAlgebra не работает, что в определенной мере сужает выразительные возможности программирования с использованием его функциональных средств. Имеется ряд других различий пакетных модулей linalg и LinearAlgebra, обусловленных проблемами полной интеграции второго в среду пакета, однако мы не будем здесь на них останавливаться. Заинтересованный же читатель отсылается к нашим книгам [13-14,29-33,39,41-43,45,46,103].

С учетом сказанного рассмотренные средства линейной алгебры и их базовые структуры данных не представляют каких-либо затруднений при использовании их знакомым с основами линейной алгебры читателем. В свете сказанного следует иметь в виду, что нами были представлены наиболее употребительные форматы матрично-векторных средств Maple-языка с определенными акцентами скорее на особенностях их реализации и выполнения, чем на их математической сущности, хорошо известной имеющим опыт в данном разделе математики. Поэтому за деталями их описания необходимо обращаться к справочной системе пакета либо к цитированной выше литературе. Однако, многие вопросы снимаются при практической апробации рассмотренных средств. В настоящее время имеется целый ряд внешних модулей пакета (часть из них поставляется по выбору), весьма существенно расширяющих рассмотренные базовые средства матричновекторных операций Maple-языка. Эти средства постоянно расширяются. На базе рассмотренных средств Maple-языка пользователь имеет возможность программировать и собственные, недостающие для решения его матрично-векторных задач, средства. Пакет постоянно, расширяя свои приложения, между тем, не в состоянии в должной мере учесть все потребности, поэтому его программная среда и предоставляет пользователям возможность расширять его новыми средствами под ваши специфические нужды. Типичным примером такого подхода и является наша Библиотека программных средств [41,42,103,109]. Ниже вопросы решения задач линейной алгебры в среде Maple (учитывая специфику настоящей книги) не рассматриваются. Заинтересованный читатель отсылается к книгам [8-14,78,84,86,88,55,59-62], а также к [91] с адресом сайта, с которого можно бесплатно загрузить некоторые книги, и к [109] с нашей Библиотекой.

• Псевдослучайные числа. Еще с одним видом значений - псевдослучайных пользователь имеет возможность работать на основе встроенного генератора псевдослучайных чисел (ГПСЧ), активизируемого по rand-процедуре, имеющей три формата кодирования. По вызову rand() возвращается псевдослучайное неотрицательное integer-число (ПСЧ) длиной в 12 цифр, тогда как по вызову rand({n|n..p}) (n, p – целочисленные значения и n ≤ p) возвращается равномерно распределенное на интервале соответственно [0 .. n] и [n .. p] целое ПСЧ. Для установки на-чального значения для ГПСЧ используется предопределенная _seed-переменная пакета, имеющая значение 427419669081, которое в любой момент может быть переопределено пользователем, например: _seed:= 2006.

Для этих же целей, но с более широкими возможностями, используется и randomize-процедура, кодируемая в одном из допустимых форматов вида: randomize({|n}), где n > 0 – целочисленное выражение, значение которого и присваивается _seed-переменной. Если используется формат randomize() вызова процедуры, то для _seed-переменной устанавливается значение, базирующееся на текущем значении системного таймера. Так как вызов randomize() возвращает базовое значение для ГПСЧ на основе текущего значения таймера, то таким способом можно достаточно эффективно генерировать различные последовательности ПСЧ. Сохраняя необходимые значения _seed-переменной, можно повторять процесс вычислений с псевдослучайными числами, что особенно важно в случае необходимости проведения повторных вычислений.

Вызов rand может инициировать вывод самого тела соответствующей ей процедуры, рекомендуемый подавлять по завершающему обращение к процедуре двоеточию. В случае же намерений пользователя написать собственную процедуру для подобных целей текст пакетной rand-процедуры может оказаться определенным прообразом. В общем же случае для обеспечения доступа к ГПСЧ рекомендуется использовать конструкции вида Id:= rand({|n|n .. p}), выполнение которых открывает доступ к последовательностям ПСЧ по вызовам Id(), каждое использование которого инициирует получение очередного равномерно распределенного на заданном интервале ПСЧ. Следующий пример иллюстрирует применение рассмотренных средств Maple-языка по работе с псевдослучайными числами:

> rand(); AVZ:= rand(1942 .. 2006): _seed:= 2006: ⇒ 403856185913

> seq(AVZ(), k=1 .. 10); ⇒ 2003, 1960, 1944, 1990, 1986, 1972, 1986, 1992, 2006, 1964

> randomize(2006): _seed; ⇒ 2006

> ПСЧ:= array[1 .. 10]: for k while k <= 10 do ПСЧ[k]:= AVZ() end do:

> seq(ПСЧ[k], k=1 .. 10); ⇒ 2005, 1946, 1958, 1951, 1983, 1992, 1946, 1955, 1995, 1951 > restart; [_seed, rand(), _seed]; ⇒ [_seed, 427419669081, 427419669081]

Наряду с приведенными Maple располагает и другими подобными средствами, в частности, для решения статистических задач (модуль stats), работы со стохастическими объектами (модуль RandomTools), стохастической генерации матриц (linalg[randmatrix]), полиномов (процедура randpoly) и др. Средства поддержки работы с псевдослучайными числами могут быть использованы во многих вычислительных задачах стохастического и квазистохастического характера, а также в задачах, требующих наборов данных для отладки программ и тестирования вычислительных алгоритмов. Рассмотренные средства широко используются нами в различного рода иллюстративных примерах для генерации разнообразных числовых данных.

Выше мы уже не раз употребляли такое понятие как математическое выражение (либо просто выражение), являющееся одним из важнейших понятий Maple, да и математики в целом. Работа с математическими выражениями в символьном виде — основа основ символьной математики. Не меньшую роль они играют и в численных вычислениях. Выражение — центральное понятие всех математических систем. Оно определяет то, что должно быть вычислено в численном или символьном виде. Не прибегая к излишнему формализму, несколько поясним данное понятие. Математические выражения строятся на основе чисел, констант, переменных, операторов, вызовов функций/процедур и различных специальных знаков, например, скобок, изменяющих порядок вычислений. Выражение может быть представлено в общепринятом виде (как математическая формула или ее часть) с помощью операторов, например, с*(х + у^2+sqrt(z)) либо (a+b)/(c+d), оно может определять просто вызов некоторой функции или процедуры F(x,y,z), либо их комбинацию. Используемые в дальнейшем многочисленные иллюстративные фрагменты представят достаточное число примеров на определение допустимых Maple-выражений, что уже практически позволит уяснить данное ключевое понятие пакета.

Наряду с рассмотренными Maple-язык поддерживает работу с рядом других структур данных (стэк, очередь, функциональные ряды, связные графы, графические объекты и т.д.). В этом направлении нами был создан ряд ролезных средств, расширяющих и дополняющих стандартные. В частности, для работы со структурами типа стэк (stack) и очередь (queue), а также введен новый тип структур прямого доступа (dirax) [41,42,103]. Пока же нам будет вполне достаточно приведенных сведений по типам данных и структур данных для понимания сути излагаемого материала, который ссылается на данные понятия. Переходим теперь к средствам Maple-языка, тестирующим вышерассмотренные типы данных, структур данных и выражений.

1.6. Средства тестирования типов данных, структур данных и выражений

Согласно аксиоматике Maple под типом понимается Т-выражение, распознаваемое typeфункцией и инициирующее возврат логического {true|false}-значения на некотором множестве допустимых Maple-выражений. В общем случае Т-выражения языка относятся к одной из четырех групп: (1) системные, определяемые идентификаторами языка {float, integer, list, set и др.}; (2) процедурные, когда тип входит в качестве аргумента в саму тестирующую функцию {type(<Выражение>, <Тип>)}; (3) приписанные и (4) структурные, представляющие собой Maple-выражения, отличные от строковых и интерпретируемые как тип {set(<Id> = float)}. К пятой группе можно отнести типы, определяемые модульными средствами пакета. Несколько детальнее о данной классификации типов будет идти речь ниже по мере рассмотрения все более сложных Maple-объектов. Уже неоднократно упоминавшееся понятие выражения, хорошо знакомое обладающему определенной компьютерной грамотностью читателю, является одним из фундаментальных понятий Maple-языка. Понятие выражения Maple-языка аккумулирует такие рассмотренные конструкции языка как константы, идентификаторы, переменные, данные и их структуры, а также рассматриваемые детально ниже функции, процедуры, модули и т. д. К выражениям в полной мере можно относить, в частности, и такие конструкции языка, как процедуры, ибо их определения допустимо непосредственно использовать при создании сложных выражений. Детальнее на данном вопросе не будем акцентироваться, а отсылаем заинтересованного читателя, например, к таким книгам как [9-14, 29-33, 59-

62, 78-89, 103].

Для определения рассмотренных типов данных и структур данных язык пакета располагает развитыми средствами, базирующимися на специальных тестирующих процедуре whattype и функциях typematch, type, имеющих следующие форматы кодирования:

{type|typematch}(<Maple-выражение>, {<Тип>|<Множество типов>}) whattype(<Выражение>)

где в качестве первого аргумента выступает произвольное допустимое Maple-выражение, а в качестве второго указывается идентификатор требуемого Типа либо их множество. Булева функция {type|typematch} возвращает логическое true-значение, если значение выражения Maple имеет тип, определяемый ее вторым аргументом, и false-значение в противном случае. При определения в качестве второго аргумента множества типов функция {type|typematch} возвращает логическое true-значение в том случае, если тип значения Maple-выражения принадлежит данному множеству, и false-значение в противном случае. При этом, следует помнить, что в качестве второго аргумента может использоваться только множество ({}-конструкция, а не []-конструкция; данное обстоятельство может на первых порах вызывать ошибки пользователей, ранее работавших с пакетом Mathematica, синтаксис которого для списочной структуры использует именно первую конструкцию). Для второго аргумента {type|typematch}-функции допускается более 202 определяемых пакетом типов (Maple 10), из которых здесь рассмотрим только те, которые наиболее употребляемы на первых этапах программирования в Maple и которые непосредственно связаны с рассматриваемыми нами конструкциями языка пакета: идентификаторы, текст, числовые и символьные данные, структуры данных и др. При этом, typematch-функция имеет более расширенные средства тестирования типов, поэтому детальнее она рассматривается несколько ниже.

Наконец, по тестирующей процедуре whattype(<Выражение>) возвращается собственно тип Maple-выражения, определяемого ее фактическим аргументом. При этом, следует отметить, что данная процедура в ряде случаев решает задачу тестирования более эффективно, например для последовательностных структур и в случае неизвестного типа, что позволяет избегать перебора подвергающихся проверке типов. Тут же уместно отметить, что средства тестирования типов, обеспечиваемые, в частности, { typematch| type}-функцией существенно более развиты, чем подобные им средства Mathematica [28-30,32,42,43]. На основе данных средств предоставляется возможность создания достаточно эффективных средств программного анализа типов данных и их структур. В табл. 5 представлены некоторые допустимые Maple-языком типы, тестируемые функцией {type|typematch} и используемые в качестве значений ее второго фактического аргумента, а также их назначение.

Таблица 5

Смысл большинства типов достаточно прозрачен и особого пояснения не требует. Таблица 5 отражает далеко не полный перечень типов, распознаваемых пакетом. Данный перечень значительно шире и с каждым новым релизом пакета пополняется новыми типами. Например, для Maple 8 этот перечень содержит 176 типов, Maple 9 – 182 и Maple 10 – 202. При этом, пользователь также имеет возможность расширять пакет новыми типами и нами был определен целый ряд новых и важных типов, отсутствующих в Maple. Все они описаны в нашей последней книге [103] и включены в прилагаемую к ней Библиотеку. Ниже мы представим механизм определения пользовательских типов. Следующий достаточно простой фрагмент иллюстрирует применения {type, typematch}-функций и whattype-процедуры:

> [whattype(64), whattype(x*y), whattype(x+y), whattype(a..b), whattype(a::name), whattype([]), whattype(a <= b), whattype(a^b), whattype(Z <> T), whattype(h(x)), whattype(a[3]), whattype({}), whattype(x,y), whattype(table()), whattype(3<>10), whattype(a..b), whattype(47.59), whattype(A and B), whattype(10/17), whattype(array(1 .. 3, [])), whattype(proc() end proc), whattype(a.b), whattype(module() end module), whattype(hfarray(1 .. 3)), whattype("a+b"), whattype(AVZ)];

[integer, *, +, .., ::, list, <=, ^, <>, function, indexed, set, exprseq, table, <>, .., float, and, fraction, array, procedure, function, module, hfarray, string, symbol]

> A:= -64.42: Art:= array(1 .. 3, 1 .. 6): S:= 67 + 32*I: V:= -57/40: L:= {5.6, 9.8, 0.2}: T:= table(): LL:=[[V, 64, 42], [G, 47, 59]]: K:= "Академия": W:= array(1 .. 100): W[57]:= 99:

> [type(A, 'algnum'), type(Art, 'array'), type(`true`, {'boolean', 'logical'}), type(S,

'complex'(integer)), type(56*Pi, 'constant'), type(56/28, 'even'), type(1.7, 'float'), type(A,

'fraction'), type(A*infinity, infinity), type(V, 'integer'), type(L, 'set'(float)), type(LL, 'listlist'), type(Art, 'matrix'), type(AVZ, 'symbol'), type(A,'negative'), type(V,'negint'), type(S,'numeric'), type(A,'rational'), type(infinity, 'realcons'), type(K, 'string'), type(Art, 'table'), type(T, 'table'), type(real, 'type'), type(W, 'vector'), type(hfarray(1 .. 3), 'hfarray')];

[false, true, true, true, true, true, true, false, true, false, true, true, true, true, true, false, false, false, true, true, true, true, false, true, true]

> map(whattype,[H, A, eval(Art),`true`, eval(T)]); ⇒ [symbol, float, array, symbol, table] > map(type, [64, 47/59, 10.17, `H`, G[3], "TRG"], 'literal'); ⇒ [true, true, true, false, false, true]

> map(type, [range, float,set, list, matrix,string,symbol, array,Array, matrix, `..`, `*`], 'type');

[true, true, true, true, true, true, true, true, true, true, true, true]

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

Так как выражение представляет собой более широкое понятие, чем данные (значения), то для тестирования их типов Maple-язык располагает достаточно развитым набором средств. Прежде всего, для прямого определения типа выражения используется уже упомянутая процедура whattype, имеющая простой формат кодирования: whattype(<Выражение>) и возвращающая тип заданного выражения, если он является одним из нижеследующих:

`*` `+` `.` `..` `::` `<` `<=` `<>` `=` `^` `||` `and` array complex complex(extended_numeric) exprseq extended_numeric float fraction function hfarray implies indexed integer list module moduledefinition `not` `or` procedure series set string symbol table uneval unknown `xor` zppoly Array Matrix SDMPolynom Vector[column] Vector[row]

Приведенный перечень идентифицируемых типов выражений, включая некоторые данные и их структуры, представлен для Maple 10, тогда как для более низких релизов этот перечень несколько короче. Следует еще раз подчеркнуть, что хотя тип последовательности (exprseq) не является определяемым функциями type, typematch типом, однако он идентифицируется whattype-процедурой. При этом, процедура возвращает только тип высшего уровня вложенности выражения в соответствии с приоритетным порядком составляющих его операторов. Следующий пример иллюстрирует применение тестирующей whattype-процедуры:

> [whattype(64), whattype(x*y), whattype(x+y), whattype(x<=y), whattype(a<>b), whattype([]), whattype(a = b), whattype(a^b), whattype(Z), whattype(h(x)), whattype(a[17]), whattype({}), whattype([]), whattype(x,y), whattype(table()), whattype(x..y), whattype(5.9), whattype(A and B), whattype(proc() end proc), whattype(module() end module), whattype(10/17), whattype("SV"), whattype(a.b), whattype(hfarray(1..10))];

[integer, *, +, <=, <>, list, =, ^, symbol, function, indexed, set, list, exprseq, table, .. , float, and, procedure, module, fraction, string, function, hfarray]

При этом, имеют место следующие идентификации типов whattype-процедурой:

{+|-} → + {/|*} → * {>=|<=} → <= {>|<} → < {**|^|sqrt(a)} → ^

{a|a."b"|a.b|a.`b`|`a`.b|`a`.`b`} → symbol {"a"|"a"."b"|"a".`b`|"a".b} → string

{array|vector|matrix} → array

что следует учитывать при использовании указанной процедуры тестирования. Обусловлено это тем обстоятельством, что предварительно вызов процедуры whattype(A) вычисляет и/или упрощает выражение А. Для расширенного тестирования типов выражений служит вышерассмотренная в связи с данными и их структурами функция {type|typematch}. Приведем простой пример на применение type-функции для тестирования выражений:

> [type(sqrt(x)+a/b, 'anything'), type(a**b, `**`), type(x*y+z^a, dependent(z)), type('a.b', `.`), type(x^a-3*x+x^4-47 = b, 'equation'), type(x^3+4*x-56, 'expanded'), type(ifactor(1998), 'facint'), type(h!, `!`), type(F(x), 'function'), type(G[47, 51, 42, 67, 62], 'indexed'), type(5*y^4

+ x^3 - 47*x, 'quartic(y)'), type(arctanh, 'mathfunc'), type(`Salcombe Eesti`, 'symbol'), type(ln, 'mathfunc'), type(10/17, 'numeric'), type(A -> B, 'operator'), type({G = 51, V = 56}, 'point')];

[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]

Следует упомянуть еще об одной тестирующей функции hastype(expr,t), чей вызов возвращает true-значение, если выражение expr содержит подвыражение заданного t-типа, и false-значение в противном случае, например:

> map2(hastype, (a*x + 10)/(sin(x)*y + x^4), ['integer', 'symbol', 'function', `*`, `+`, symbol^integer]);

[true, true, true, true, true, true]

> map2(hastype, (10^Kr + 96)/(Art^17 + 89), [even^symbol, symbol^odd]); ⇒ [true, true]

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

Дополнительно к рассмотренным средствам тестирования рассмотрим еще 6 весьма полезных процедур из класса так называемых is-процедур языка. Прежде всего, процедура isprime(n) осуществляет стохастическую проверку n-числа на предмет его простоты, тогда как процедура issqr(n) тестирует наличие точного квадратного корня из целого n-числа. Процедура is(V, <Свойство>) тестирует наличие у V-выражения указанного свойства, тогда как процедура ispoly(P, {1|2|3|4}, x) тестирует будет ли P-выражение полиномом {1|2|3|4}-степени по ведущей х-переменной. Процедура isdifferentiable(V,x,n) тестирует V-выражение, содержащее кусочно-определенные функции (abs, signum, max и др.), на предмет принадлежности его к Cⁿ -классу по ведущей х-переменной. Наконец, процедура iscont(W, x=a .. b{, 'closed'}) тестирует факт наличия непрерывности W-выражения на [a, b]-интервале по x-переменной, включая его граничные точки, если закодирован необязательный closed-аргумент. Простой фрагмент иллюстрирует использование указанных is-процедур:

> iscont(x*sin(x) + x^2*cos(x), x= -Pi..Pi, 'closed'); ⇒ true

> isprime(1999), isprime(1984979039301700317); ⇒ true, false

> issqr(303305489096114176); ⇒ true

> x:= 32: is(3*sin(x) + sqrt(10) + 0.42, 'positive'); ⇒ true

> ispoly(3*h^4 - 10*h^3 + 32*h^2 - 35*h + 99, 'quartic', h); ⇒ true

> isdifferentiable(y*(abs(y)*y + signum(y)*sin(y)), y, 2); ⇒ false

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

> type([64, V, sqrt(Art)], [integer, name, `^`]), type(59^sin(x), integer^trig); ⇒ true, true

> type(G(x)^cos(y), function^symmfunc), type(sqrt(F(x)), sqrt(function)); ⇒ true, true

> type(57+sin(x)*cos(y), `&+`(integer, `&*`(trig, symmfunc))); ⇒ true

> type(sqrt(Art^10 + Kr^3 + 99),sqrt(`&+`(name^even, symbol^odd, integer))); ⇒ true

> type((G(x) + cos(y))^(47*I + sin(x)),(`&+`(function, trig)^`&+`(complex, trig(x)))); ⇒ true Из примеров представленного фрагмента вполне прозрачно прослеживается тесная взаимосвязь между структурным деревом термов тестируемого выражения и выбранным для него структурированным типом. Детальнее с вопросами структурированных типов языка можно ознакомиться по книгам [33,42,45,83] либо оперативно по конструкции вида ?type, {anyfunc| identical|specfunc|structure} в среде текущего сеанса пакета.

Следует иметь в виду, что по конструкции следующего простого вида: type('<Id>', name(<Тип>))

предоставляется возможность тестировать тип присвоенного Id-идентификатору значения, как это иллюстрирует следующий весьма простой фрагмент:

> GS:= cos(x)*sin(y) + F(z) + 99: AV:= 42 .. 64: type('AV', name(range)); ⇒ true

> SV:= sqrt(Art + Kr): type('SV', name(sqrt(`&+`(name, symbol)))); ⇒ true

> type('GS', name(`&+`(`&*`(symmfunc, trig), function, odd))); ⇒ true

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

Особого внимания заслуживают еще две тестирующие функции, позволяющие проводить структурное тестирование типов как выражений, так и составляющих их подвыражений. В частности, hastype-функция имеет следующий формат кодирования: hastype(<Выражение>, <Структурированный тип>)

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

> Kr:= 10*sin(x) + 17*cos(y)/AV + sqrt(AG^2 + AS^2)*TRG + H^3 - 59*sin(z) - Catalan:

> map2(hastype,Kr, [name^integer,constant,sqrt,fraction,`*`]); ⇒ [true, true, true, true, true]

> map2(has,Kr,[10*sin(x), 1/AV, AG^2+AS^2, H^3,-59*sin(z)]); ⇒ [true, true, true, true, true] > [hasfun(Kr, sin, z), map2(hasfun, Kr, [sqrt, sin, cos])]; ⇒ [true, [false, true, true]]

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

По тестирующей функции has(<Выражение>, <Подвыражение>) производится проверка на наличие вхождения в заданное первым аргументом выражение указанного вторым аргументом подвыражения. Если в качестве второго аргумента has-функции указан список подвыражений, то выражение подвергается тестированию по каждому из подвыражений списка. Функция возвращает true-значение, если факт вхождения установлен, и falseзначение в противном случае. При этом, в случае списка подвыражений в качестве второго аргумента has-функция возвращает true-значение только тогда, когда имеет место факт вхождения в тестируемое выражение по крайней мере одного из подвыражений указанного списка. Второй пример предыдущего фрагмента иллюстрирует сказанное. Данная функция представляет большой интерес в задачах структурного анализа символьных выражений, поступающих в качестве входной информации для процедур символьных обработки и вычислений.

Наконец, по тестирующей функции hasfun(V,<Id-функции> {,x}) возвращается значение true, если определенное первым фактическим аргументом V-выражение содержит вхождение функции, заданной своим идентификатором, и, возможно, от указанной третьим необязательным аргументом ведущей х-переменной. Последний пример предыдущего фрагмента не только иллюстрирует вышесказанное, но и указывает на то, что, в частности, sqrt-функция не тестируется hasfun-функцией. Ряд дополнительных вопросов, относящихся к тестированию выражений, рассматривается несколько ниже.

Начиная с Maple 8, пакет пополнен модулем TypeTools, пять процедур которого служат для расширения списка типов, стандартно прддерживаемых type-функцией. Со своей стороны, еще раньше мы определили процедуру usertype, обеспечивающую ряд массовых операций для работы с пользовательскими типами, поддерживаемых процедурами с именами формата 'type/name', where name – имя пользовательского типа.

Модуль TypeTools может быть использован для расширения стандартной type-функции пакета типами, определенными пользователем, однако его применение приводит к созданию двух непересекающихся систем типизации в среде Maple, а именно: (1) системе типов пользователя, базирующейся на конструкциях вида `type/name`:=proc ... end proc, сохраненных в Maple-библиотеках, и (2) системе, базирующейся на модуле TypeTools.

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

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

аргументы отсутствуют – возвращает списки всех имен типов формата `type/name`, на- ходящихся во всех Maple-библиотеках, определяемых предопределенной libname- переменной. Данная функция позволяет получать только имена типов, зарегист- рированных, используя вышеуказанный метод. В частности, она не может исполь- зоваться для получения встроенных типов и созданных на основе TypeTools-моду- ля. Каждый возвращаемый вышеуказанный список предваряется полным путем к Maple-библиотеке, содержащей определения типов, чьи имена находятся в списке; 'active' – возвращает список имен вида `type/name`, активных в текущем сеансе;

L – возвращает список имен типов вида `type/name`, расположенных в Maple- библиотеке, определенной полным путем L к ней. Список предваряется полным путем к Maple-библиотеке, содержащей определения типов; name, 'code' – возвращает исходный текст процедуры `type/name`;

L, name – помещает определение типа `type/name` в Maple-библиотеку, определен- ную полным путем L к ней. Процедура `type/name` должна иметь boolproc- тип. В данном случае вызов процедуры usertype(L,name) выводит соответ- ствующие сообщения;

L, name, 'del' – удаляет определение типа `type/name` из Maple-библиотеки, полный туть к которой определен аргументом L. Никаких сообщений не выводится.

В процессе использования для Maple релизов 6-7 процедура usertype проявила себя достаточно эффективным средством.

Еще на одном весьма существенном моменте следует акцентировать ваше внимание. В среде пакета вызов type(Х, 'type') тестирует выражение Х на предмет быть допустимым выражением типа, т.е. опознаваемым встроенной type-функцией в качестве типа. При этом, по определению под выражением типа Х понимается такое выражение, для которого успешно выполняется вызов type(<Выражение>, Х), где в качестве первого аргумента выступает произвольное Maple-выражение. В качестве типов допускаются системные типы {integer, float, symbol, string и др.}, типы, определяемые процедурами с именами формата `type/name`, а также типы, определяемые присвоением либо комбинацией типов. Однако, данная проверка не столь корректна, как декларируется. Следующий простой фрагмент подтверждает вышесказанное.

В первой части производится тестирование типов, определенных средствами TypeToolsмодуля и процедурами с именами вида `type/name`. Оказывается, что во втором случае вызов type(neg, 'type') некорректно тестирует neg-тип. Затем определяется `type/Type`процедура, устраняющая данный недостаток. В заключительной части фрагмента данная процедура проверяется на предмет корректности, демонстрируя, что она решает задачу тестирования типов успешнее стандартного средства, обеспечивая корректное тестирование типов, определенных любым допустимым в Maple способом.

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

1.7. Конвертация Maple-выражений из одного типа в другой

Так как многие типы числовых значений взаимно обращаемы, то Maple-язык пакета для конвертации одного типа в другой располагает достаточно развитыми средствами, базирующимися на многоаспектной convert-функции, которая служит не только для конвертации значений из одного типа в другой, но и конвертации выражений в целом из одного типа в другой, при этом понятие типа трактуется существенно более широко, чем мы говорили до сих пор, например, можно конвертировать выражения, содержащие волновые Айри-функции, в выражения с функциями Бесселя и т.д. В общем случае функция convert имеет следующий формат кодирования: convert(<Выражение>, <Формат> {, <Список опций>})

где выражение представляет собственно сам объект конвертации, формат определяет тип конвертации (его в случае столь широкого толкования понятия “тип” вполне допустимо называть более емким понятием “формат“), а необязательный третий аргумент функции составляет Список опций, определяемых спецификой используемого второго Формат-аргумента функции. Язык пакета для convert-функции в качестве значения ее второго аргумента допускает следующие форматы (типы) конвертации:

0F1 1F1 2F1 Abel Abel_RNF abs Airy algebraic and arabic arctrig arctrigh I array base Bessel Bessel_related binary binomial boolean_function boolean_operator bytes Chebyshev compose confrac conversion_table Cylinder D decimal egrees DESol diff dimensions disjcyc Ei_related elementary Elliptic_related equality erf erfc erf_related exp expln expsincos factorial FirstKind float fullparfrac GAMMA function_rules GAMMA_related global Hankel eaviside eun hex hexadecimal Int hypergeom int iupac Kelvin Kummer Legendre linearODE list listlist ln local mathorner Matrix

matrix MeijerG metric MobiusR MobiusX MobiusY mod2 ModifiedMeijerG multiset name NormalForm numericproc octal or package parfrac permlist piecewise polynom PLOT3Doptions PLOToptions polar POLYGONS power pwlist radians radical set rational ratpoly RealRange record relation Riccati roman RootOf SecondKind std

signum sincos sqrfree StandardFunctions stdle string Sum sum surd symbol tan

system table temperature to_special_function trig trigh truefalse units unit_free Vector vector Whittaker windchill xor y_x `*` `+`

Уже из простого перечисления допустимых видов конвертации (в количестве 137 для пакета Maple 10) следуют весьма широкие возможности convert-функции. Многие из них будут достаточно детально рассмотрены в настоящей книге в различных контекстах, с другими можно детально ознакомиться по справочной системе пакета либо по книгам [34,42,56,63,78,96]. В представительном отношении набор допустимых форматов конвертации относительно предыдущих релизов пакета в Maple 10 увеличился, да и в качественном отношении произведено существенное расширение механизма конвертации типов. Данное обстоятельство существенно расширило возможности Maple-языка по преобразованию типов и форматов представления выражений. Следующие довольно распространенные форматы конвертации типов выражений представлены в табл. 6.

Таблица 6

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

С учетом сказанного приведенный фрагмент использования вышерассмотренных пакетных средств конвертации типов (форматов) выражений в широком понимании данного термина представляется достаточно прозрачным и особых пояснений не требует. Более детальное ознакомление со средствами данного класса Maple-языка рекомендуется проводить при непосредственной практической работе в его среде. Нами также был определен ряд довольно полезных средств конвертации объектов Maple-типа в объекты типа rtable, и наоборот [103]. Например, вызов нижеприведенной процедуры avm_VM(G) возвращает результат преобразования объекта, определенного фактическим аргументом G типа {array, vector, matrix}, в объект типа {Vector, Matrix}, и наоборот – объект типа {Vector, Matrix} в векторы или матрицы типа Maple.

При этом, следует отметить, что в нашей книге [12] (прилож. 1) представлен целый ряд особенностей выполнения конвертации выражений одного типа в другой посредством convert-функции, имеющих важное значение при практическом использовании данного средства. Там же приведены и другие полезные замечания относительно convert-функции, сохраняющие свою актуальность и для последующих релизова Maple.

Следует отметить, что в таблицах главы и в последующих не приводится исчерпывающей характеристики функций либо других средств Maple-языка, а только основные их назначение и аргументы. Некоторые их особенности приводятся в прилож. 3 [12], полную же информацию по любой функции, поддерживаемой пакетом, можно оперативно получать по конструкции ?<функция> или в документации по Maple, например, [8183,89]. Следует еще раз напомнить, что кодирование идентификаторов в пакете Maple регистро-зависимо, поэтому необходимо правильно кодировать все используемые идентификаторы. Несоблюдение данного условия лежит в основе многих ошибок.

1.8. Функции математической логики и средства тестирования пакета

Для решения задач математической логики, пропозиционального исчисления, а также организации логических конструкций, управляющих вычислительным процессом в документе Maple либо программе (условные переходы, ветвления, циклические и итеративные вычисления и др.), Maple-язык располагает рядом встроенных, библиотечных и модульных процедур и функций, операторов и иных конструкций, значения аргументов или возвращаемых результатов которых получают логические значения true (истина), false (ложь) и FAIL (неопределенность). К группе данных средств относятся и так называемые тестирующие функции и процедуры. Такие средства в зависимости от результата тестирования своего аргумента возвращают значение true или false. Ряд свойств таких функций нами рассматривался выше в связи с другими вопросами Maple-языка, остальные будут рассматриваться здесь и в последующих разделах по мере необходимости и в контексте с различными вопросами практического программирования.

В основе математической логики, поддерживаемой Maple-языком, лежит понятие булевого (boolean; логического) выражения. Как уже отмечалось, Maple-язык поддерживает трехзначную логику {true, false, FAIL} для всех булевых операций. Булевы выражения формируются на основе базовых логических операторов {and, or, not}, образующих функционально полную систему (в смысле возможности представления на их основе произвольной логической функции) и операторов отношения {< (меньше)|<= (не больше)|> (больше)|>= (не меньше)|= (равно)|<> (не равно)}. Булевский (boolean) тип идентифицируется тестирующими функциями type и typematch, и процедурой whattype; и при этом, Maple-язык дифференцирует boolean-тип на два базовых подтипа: relation и logical. К relation-подтипу относятся выражения вида {<|<=|=|<>}, а к logical-подтипу - выражения вида {or, and, not}; тогда как boolean-тип определяют как собственно выражения двух указанных подтипов, так и их сочетания, а также логические константы {true, false}. Все логические типы тестируются {type|typematch}-функцией следующего формата кодирования:

{type|typematch}(<Выражение>, {boolean|relation|logical})

как это иллюстрирует следующий простой пример:

> [type(AV <> 64, 'relation'), type(AV and AG, 'logical'), type(true <> false, 'boolean')],

[whattype(AV and AG), typematch(AV <> 59, 'relation')]; ⇒ [true, true, true], [and, true] Для вычисления Maple-выражений в булевой трактовке используется evalb-функция, имеющая простой формат кодирования: evalb(<Выражение>) и возвращающая логическое значение {true|false|FAIL}; если это невозможно, то выражение возвращается невычисленным. Основной задачей evalb-функции является вычисление Maple-выражений, содержащих операторы отношения, в терминах логических значений. Это необходимо в целом ряде случаев, связанных с различного рода задачами анализа вычислительных конструкций, ибо Maple-язык трактует выражения, содержащие операторы отношения, как алгебраические уравнения или неравенства, если выражения дополнительно не содержат логических {and, or, not}-операторов. И только в качестве аргументов evalb-функции либо в {if|while}-предложениях Maple-языка они получают логическую трактовку. При этом, следует иметь в виду, что Maple-язык конвертирует выражение, содержащее операторы отношения {>, >=}, в эквивалентное ему выражение в терминах {<, <=}-операторов. Более того, т.к. evalb-функция не производит упрощения выражения-аргумента, то в ряде случаев ее применение может приводить к некорректным результатам. Поэтому, перед вызовом evalb-функции рекомендуется предварительно упрощать выражение, передаваемое ей в качестве фактического аргумента; это можно, в частности, делать и по simplify-функции. Простой фрагмент иллюстрирует вышесказанное:

> whattype(AVZ = AGN), evalb(AVZ = AGN), evalb(AVZ = AVZ); ⇒ =, false, true

> AV:= 64: whattype(AV <= 64), evalb(AV = 64), evalb(AV <= 64); ⇒ <=, true, true > whattype(sqrt(64) <> ln(17)), evalb(sqrt(64) <> ln(17)); ⇒ <>, true

Следует иметь в виду, что вычисление логических выражений подчиняется следующему правилу: первым вычисляется левый операнд {and|or}-оператора и вычисление правого его операнда производится только тогда, когда логическое значение левого операнда может способствовать получению true-значения выражения в целом. Так, правый операнд логического and-выражения следующего вида:

> G:= 0: V:= 17: if (G = 64) and (V/G >= 0.25) then printf(`%3s\%4f`, `G=`, V/G) end if;

> G:= 0: V:= 20: if (G = 52) or (V/G >= 9.47) then printf(`%3s\%4f`, `G=`, V/G) end if; Error, numeric exception: division by zero не вычисляется и не вызывает ошибочной ситуации “деления на нуль”, т.к. левый его операнд (G = 64) для G = 0 при вычислении возвращает false-значение, не способствующее получению true-значения and-оператора в целом, независимо от результата вычисления его правого операнда, вызывающего на данном G-значении указанную ошибочную ситуацию. Иная ситуация, как показано, имеет место для случая or-оператора.

Правила выполнения логических {and,or,not}-операторов на {true, false, FAIL}-значениях в качестве операндов определяются следующими таблицами истинности:

Смысл приведенных правил достаточно прозрачен и пояснений не требует, например: > [FAIL and true, false or FAIL, true or FAIL, not FAIL]; ⇒ [FAIL, FAIL, true, FAIL]

Следует отметить, что до 6-го релиза Maple для расширения круга решаемых задач математической логики и ее приложений дополнительно предоставлял 10 модульных функций, поддерживаемых средствами logic-модуля. Однако, после нашей принципиальной критики ряда его функций, точнее результатов вызовов bequal-функции на FAIL-значениях [10-12], данный модуль был исключен из Maple. И аналога этого (в целом весьма полезного) модуля не было до Maple 10. И только в последнем релизе появился модуль Logic, чьи средства предна-начены для работы с выражениями, используя двузначную булеву логику, т.е. без FAIL-значения. По конструкции ?Logic читатель может детально ознакомиться со средствами данного модуля.

Для обеспечения логических операций и по-битной (поразрядной) обработки информации нами также был определен ряд процедур и модулей [42,103,109]. Так вышеприведенная процедура Bit(B, bits) обеспечивает выполнение следующих базовых по-битных операций с символом, указанным первым аргументом В (в качестве В могут выступать 1-элементные строка либо символ, а также 1-элементный список, чей элемент определяет десятичный код символа из диапазона 0..255):

(1) если второй аргумент bits имеет вид [n1, n2, …], вызов процедуры Bit(B, bits) возвращает значения битов символа B, расположенных в его позициях nj (nj лежит в 1 .. 8); (2) если второй аргумент bits имеет вид [n1 = b1, n2 = b2, …], возвращается десятичный код символа, полученного заменой значений битов символа В (в его позициях nk) на бинарные значения bk (nk = 1..8; bk = {0|1}).

(3) если второй аргумент bits – имя процедуры, определенной над списками, возвращается результат применения процедуры к списку значений всех битов символа В.

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

Базовые средства поддержки булевой алгебры обеспечиваются модулем boolop, а также нижеследующей процедурой BitWise [103,108,109]:

Вызов процедуры BitWise(BO, n {, m}) возвращает результат поразрядной операции ВО над бинарными числами n {и m}. При этом в качестве ВО выступают традиционные булевы операции {AND, OR, XOR, NOR, NOT, IMPL}, где IMPL обозначает implies-операцию; тогда как ADD – операция поразрядного сложения по mod 2.

Так модуль boolop [109] экспортирует ряд полезных функций/операторов, обеспечивающих базовые операции булевой алгебры, а именно:

&andB, &orB, &xorB, &notB, &impB

где, в частности, &andB – n-арная логическая функция/оператор and:

Следующая процедура logbytes обеспечивает поддержку базовых логических операций {xor, and, or, not, implies} над последовательностями байтов типа {string, symbol}.

Логические операции производятся над соответствующими битами байтов, определенных последовательностью аргументов, начиная со второго. Тогда как в качестве первого О-аргумента выступают указанные логические операции. Результат возвращается в виде байта в string-формате. При этом, предполагаются n-арные операции {`xor`,`and`,`or`}, бинарная операция `implies` и унарная `not`.

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

• Тестирующие функции, значительная часть которых рассмотрена выше, возвращают значение {true|false} в зависимости от {истинности|ложности} того или иного проверяемого логического условия (теста). И в этом смысле они могут входить в состав булевых выражений. Выше был рассмотрен целый ряд тестирующих функций, обеспечиваемых языком пакета. В дальнейшем оставшиеся функции данного типа будут представлены при обсуждении соответствующих приложений Maple-языка.

Здесь мы несколько расширим наше представление о концепции типов, поддерживаемой пакетом. Как уже отмечалось выше, базовыми тестирующими средствами являются функции type и typematch, а также процедура whattype. Третья из них возвращает поддерживаемый Maple тип указанного своим фактическим аргументом Maple-выражения, тогда как две первые возвращают {true|false}-значение в зависимости от {истинности| ложности} факта эквивалентности типа, указанного их первым фактическим аргументом (выражение) и их вторым фактическим аргументом – идентификатором типа, распознаваемого Maple-языком.

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

algebraic anything applied array boolean equation even float fraction function list

indexed integer laurent linear listlist logical mathfunc matrix moduledefinition odd monomial name negative nonnegative numeric point positive procedure radical

range rational relation RootOf rtable scalar SDMPolynom SERIES series set sqrt

string table taylor trig type uneval vector zppoly `!` `*` `+` `..` `.` `<=` `<>`

`<` `=` `and` `intersect` `minus` `module` `not` `or` `union` `^`

Большинство тестируемых вышеупомянутыми средствами Maple-языка типов относятся именно к первой группе – внешним типам. Типы, требующие для своего тестирования анализа (возможно рекурсивного) всего структурного дерева выражений, относятся ко второй группе – вложенным типам. В качестве вложенных Maple-язык рассматривает следующие 13 типов выражений, а именно:

algfun algnum appliable constant cubic expanded linear polynom quadratic quartic radfun radnum ratpoly

Все вышеперечисленные типы относятся к пакету Maple 10. Следует отметить, что константный тип относится ко второй группе, т.к. для его тестирования требуется анализ всего структурного дерева выражений на предмет отсутствия вхождения в него переменных компонент, т.е. х-компонент, для которых имеет место определяющее соотношение type(x,name) ⇒ true. В приводимых ниже примерах будут детализированы многие практические аспекты работы с типами при организации различных вычислительных конструкций, использующих функциональные средства Maple-языка.

По testeq-процедуре, имеющей формат кодирования testeq(A { {,|=} B}), производится стохастическое тестирование эквивалентности двух Maple-выражений либо эквивалентность заданного единственным фактическим аргументом выражения нулю. В случае установления факта эквивалентности возвращается true-значение, в противном случае – false-значение. При этом, false-значение является достоверным, тогда как значение true возвращается корректно с очень высокой степенью достоверности. В процессе тестирования процедура не только производит вычисления выражений-аргументов, но и их алгебраические преобразования и упрощения. При невозможности произвести тестирование возвращается FAIL-значение. Простой пример иллюстрирует вышесказанное:

> [testeq(sin(x)/cos(x), tan(x)), testeq(sin(x)^2 + cos(x)^2 - 1)]; ⇒ [true, true]

> [testeq(sqrt(-1) - I), testeq(x^2 + 4*x + 4, (x + 2)^2)]; ⇒ [true, true]

Весьма важной для задач формального анализа Maple-выражений представляется тестирующая match-процедура, имеющая следующий формат кодирования: match(<Выражение> = <Шаблон>, <Id>, '<Id_1>')

и возвращающая true-значение, если устанавливается соответствие структуры тестируемого, заданного первым аргументом, выражения указанному вторым аргументом функции шаблону по указанной ведущей Id-переменной. Шаблон представляет собой выражение по ведущей Id-переменной с формальными параметрами, на соответствие структуре которого и производится проверка выражения. Например, выражение z+a*x^2+b*x+c определяет шаблон квадратного трехчлена по ведущей х-переменной. В случае успешного тестирования в невычисленную Id_1-переменную помещается множество значений параметров шаблона, на которых он структурно эквивалентен тестируемому выражению. Следующий простой фрагмент иллюстрирует вышесказанное:

> [match(ln(Pi)/ln(x) + x^y = a/ln(x) + x^b, x, 'h'), h]; ⇒ [true, {b = y, a = ln(π)}] > [match(1942*sqrt(x) + 64^x - 10*y = a*x^d + b^x + c, x, 'h'), h];

[true, {a = 1942, d = 1/2, c = -10 y, b = 64}]

> [match(ln(z)*sqrt(x) + z^x - 10*y = a*x^b + c^x + d, x, ‘h’), h];

Механизм шаблонов, поддерживаемый match-процедурой, позволяет устанавливать точную структуру Maple-выражений на основе заданного структурного шаблона с формальными параметрами, вычисляя значения последних (если установлено соответствие тестируемого выражения шаблону) по принципу функционального уравнения. Между тем, успешное применение match-процедуры для структурного тестирования выражений предполагает представление их в алгебраическом виде. В противном случае match-процедура может необоснованно возвращать false-значение, например:

Во избежание подобной ситуации выражения, содержащие числовые значения, рекомендуется предварительно конвертировать в эквивалентные выражения rational-типа.

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

typeindex undefined uneval union unit unit_name Vector vector verification verify xor with_unit zppoly ^ ||

Данные идентификаторы используются в качестве фактического значения второго аргумента {type|typematch}-функции либо возвращаются whattype-процедурой в результате тестирования Maple-выражений. Часть данных типов рассматривалась выше, многие из оставшихся типов будут рассмотрены ниже при обсуждении соответствующих вопросов Maple-языка. В представленном списке количество типов больше, чем в предыдущих релизах пакета и, как правило, с ростом номера релиза количество поддерживаемых им типов также растет.

В качестве типов, отличных от базовых (представляемых единым идентификатором, принадлежащим приведенному выше списку, например: integer, trig, list, set, float и др.), Maple-язык поддерживает структурные типы, формальный синтаксис которых может описывать основную структуру тестируемых выражений. Maple-язык допускает структурные типы двух видов: простые и функциональные. Простые структурные типы имеют следующий синтаксис: <Тип_1>#<Тип_2>, где два базовых типа соединены знаком оператора (#); в качестве основных язык для них допускает следующие: `=` `<>` `<` `<=` `>` `>=` `..` and or not &+ &* `^` `.`. А также: '<Тип>', [<Тип>], name[<Тип>] и fcntype, определяющие соответственно невычисленное выражение, список, индексированную ссылку указанного типа и функцию специального типа. В качестве функционального структурного типа Mapleязык допускает следующие основные синтаксически корректные конструкции:

set(<Тип>) – множество элементов заданного типа; list(<Тип>) – список элементов заданного типа;

`&+`(<Тип>) – сумма термов заданного типа;

`&*`(<Тип>) – произведение сомножителей заданного типа; identical(<Выражение>) – выражение, идентичное заданному; anyfunc(<Тип>) – произвольная функция заданного типа, кроме exprseq; function(<Тип>) – произвольная функция с аргументами заданного типа; specfunc(<Тип>, F) – функция F с аргументами заданного типа.

Наряду с рассмотренным выше механизмом шаблонов Maple-язык поддерживает и механизм типированных шаблонов, базирующийся на структурных типах, typematch-функции и (::)-операторе типизации. По (::)-оператору, имеющему максимальный приоритет, конструкция вида Id::<Тип> приписывает Id-идентификатору заданный тип, который может быть как базовым, так и структурным. Рассмотренная в общих чертах typematchфункция имеет формат кодирования следующего вида: typematch(<Выражение>, <Типированный шаблон> {, '<Id>'})

В рамках первых двух аргументов typematch-функция совпадает с type-функцией и возвращает true-значение в случае соответствия типированной структуры тестируемого выражения заданному вторым аргументом типированному шаблону, определяемому базовым либо структурным типом, иначе возвращается false-значение.

Третий же ее необязательный 'Id'-аргумент определяет невычисленную переменную и в сочетании с (::)-оператором типирования позволяет существенно расширять механизм типированных шаблонов. Суть расширения данного механизма сводится в общих чертах к следующему: в типированный шаблон, определяемый в качестве второго фактического аргумента typematch-функции, каждому типу посредством (::)-оператора приписывается некоторая переменная (типированная) и в случае возврата функцией true-значения в переменную, определяемую третьим фактическим аргументом, помещается список конкретных значений типированных переменных шаблона, на которых тестируемое выражение, определяемое первым фактическим аргументом функции, обеспечивает возврат true-значения. Следующий несложный фрагмент иллюстрирует ряд примеров применения тестирующих функций {type, typematch}:

С учетом сказанного приведенный фрагмент достаточно прозрачен и каких-либо особых пояснений не требует. Вместе с тем, механизмы шаблонов, поддерживаемые Mapleязыком требуют для хорошего усвоения определенной наработки по их использованию, т. к. содержат целый ряд особенностей, здесь не рассматриваемых (см. прилож. 1 [12]).

Структурные типы обоих видов (простого и функционального) в сочетании с typematchфункцией позволяют достаточно эффективно тестировать структурную организацию Maple-выражений, однако в отличие от рассмотренного выше механизма шаблонов, поддерживаемого match-процедурой, в первом случае производится тестирование только структурно-типированного соответствия искомого выражения, определяемого первым фактическим аргументом typematch-функции, с заданным ее вторым аргументом-шаблоном. Тогда как по match-процедуре производится тестирование соответствия искомого выражения, определяемого левой частью равенства, правой части, определяющей шаблон, в математическом контексте, производя, при необходимости, вычисления и упрощения как исходного выражения, так и самого шаблона.

Вместе с тем, для обеспечения структурного типированного анализа выражений весьма полезной представляется patmatch-процедура, имеющая формат кодирования: patmatch(<Выражение>, <Шаблон> {, 'h'})

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

Шаблон представляет собой типированное (::)-оператором алгебраическое выражение от ведущих переменных исходного выражения, на соответствие которому оно и проверяется. Процедура patmatch возвращает true-значение, если устанавливается структурно-типированное соответствие тестируемого выражения заданному шаблону, и false-значение в противном случае. В первом случае необязательной h-переменной присваивается список уравнений таких, что имеет место соотношение subs(h, <Шаблон>) = <Выражение>, во втором – h-переменная возвращается невычисленной (неопределенной). При этом, patmatch-процедура допускает использование и специального ключевого слова conditional, обеспечивающего возможность определения для шаблона дополнительных условий. Такие условия кодируются в одном из следующих двух форматах, а именно: conditional(<Шаблон>, <Условие>) и conditional(<Шаблон> = <B>, <Условие>)

В качестве условия выступают корректные булевские выражения, включающие типированные параметры шаблона, операторы отношения и логические операторы {and, or, not}. Вместе с тем, условие может включать и произвольные булевские функции и процедуры, возвращающие логические значения, например: isprime, issqr, type, typematch, match и даже patmatch, что позволяет производить рекурсивный структурно-типированный анализ Maple-выражений. Следующий фрагмент иллюстрирует применение процедуры patmatch для структурно-типированного анализа алгебраических выражений:

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

Еще на одном функциональном средстве Maple-языка, использующем механизм шаблонов и табличную структуру данных, следует остановиться особо. По вызову процедуры compiletable([Шаблон_1 = Выход_1, …, Шаблон_n = Выход_n])

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

Тогда по вызову процедуры tablelook(<Выражение>, CT) возвращается выход СТ-таблицы, входу которого по шаблону соответствует указанное первым фактическим аргументом выражение. В случае отсутствия в СТ-таблице входа, по шаблону соответствующего выражению, процедурой возвращается FAIL-значение. Модифицировать СТ-таблицу путем добавления в нее новых входов можно посредством insertpattern-процедуры, по которой новые входы помещаются в конец таблицы. При необходимости помещения нового входа в другое место требуется новая компиляция СТ-таблицы. Следующий простой фрагмент иллюстрирует использование указанных средств Maple-языка для создания таблицы интегралов от простых выражений, содержащей только четыре входа (шаблоны подинтегральных выражений) и в качестве соответствующих им выходов – результаты интегрирования исходных шаблонов-выражений.

Из представленного фрагмента достаточно прозрачен сам принцип создания функциональной СТ-таблицы и последующего ее использования. Рассмотренные средства пакета Maple обеспечивают простую возможность создания различного рода функциональных таблиц с параметрами и достаточно быстрого их просмотра. При этом, следует иметь в виду, что созданная таким образом функциональная таблица не является в строгом понимании Maple-языка структурой данных table-типа, как это иллюстрирует последний пример предыдущего фрагмента. Более детально читатель может ознакомиться с принципами организации функциональных таблиц в книгах [80,84,86-88].

При этом, следует отметить, что в определенной мере типировать идентификаторы можно и по assume-процедуре, как это иллюстрирует следующий простой пример:

> assume(A, integer); assume(B > 0); frac(A), sin(A*Pi), sqrt(-B); ⇒ ^{0 0, , B~ I}

Аппарат шаблонов Maple-языка представляет собой довольно развитое уникальное средство, позволяющее проводить структурно-типированный анализ Maple-выражений, однако он не позволяет наделять конструкции языка требуемыми свойствами, подобно тому, как это делает подобный ему механизм математического пакета Mathematica. В деталях данный вопрос здесь не обсуждается и заинтересованный читатель отсылается к книгам [10-14,29,30,84].

Вместе с тем, (::)-оператор типирования поддерживает механизм автоматической проверки типов, передаваемых процедуре значений фактических аргументов, что при конкретном программировании используется весьма широко. В данном случае определяемые в процедуре формальные аргументы по (::)-оператору наделяются соответствующими типами (типируются), позволяя при вызове процедуры на фактических аргументах проверять их допустимость на заданные типы. В дальнейшем указанные средства тестирования типов будут широко использоваться в многочисленных иллюстративных примерах, детализируя их смысловую нагрузку. По конструкции ?{type|typematch|whattype} можно оперативно получать справочную информацию по {type, typematch, whattype} и список всех поддерживаемых Maple-языком типов. Ряд важных особенностей выполнения рассмотренных тестирующих функций можно найти в [12,91], тогда как с введенными нами новыми важными типами можно ознакомиться в [42,103,108,109].

В частности, нами был определен новый file-тип, поддерживаемый процедурой:

Вызов type(K, file) возвращает true, если K – реальный файл, иначе false возвращается.

Глава 2. Базовые управляющие структуры Mapleязыка пакета

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

2.1. Предварительные сведения общего характера

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

В задачу структурного кодирования входит получение корректной программы (модуля) на основе простых управляющих структур. В качестве таких базовых выбираются управляющие структуры следования, ветвления, организации циклов и вызовов функций (процедур, программ); при этом, все перечисленные структуры допускают только один вход и один выход. Более того, первые из трех указанных управляющих структур (следования, ветвления и организации циклов) составляют тот минимальный базис, на основе которого можно создавать любой сложности корректную программу с одним входом, одним выходом, без зацикливаний и недостижимых команд. Детальное обсуждение базисов управляющих структур программирования можно найти, в частности, в книгах [1-3] и в другой доступной литературе по основам программирования.

Следование отражает сам принцип последовательного выполнения предложений программы, пока не встретится изменяющее эту последовательность предложение. Например: Avz:=19.4; Ag:=47.52; Sv:=39*Av-6*Ag; Tal:=Art+Kr; - типичная управляющая структура следования, состоящая из последовательности четырех весьма простых Maple-предложений присваивания.

Ветвление определяет выбор одного из возможных путей дальнейших вычислений; типичными предложениями, обеспечивающими данную управляющую структуру, являются предложения типа «IF A THEN B ELSE C». Структура «цикл» реализует повторное выполнение группы предложений, пока выполняется некоторое логическое условие; типичными предложениями, обеспечивающими данную управляющую структуру, являются предложения: DO, DO_WHILE и DO_UNTIL. Таким образом, базисные структуры определяют соответственно последовательную (следование), условную (ветвление) и итеративную (цикл) передачи управления в программах. При этом, корректная структурированная программа теоретически любой сложности может быть написана с использованием только управляющих структур следования, IF-операторов ветвления и WHILEциклов. Однако расширение набора указанных средств, в первую очередь, за счет обеспечения вызовов функций и механизма процедур существенно облегчает программирование, не нарушая при этом структурированности программ и повышая уровень их модульности. При этом, сочетания (итерации, вложения) корректных структурированных программ, полученные на основе указанных управляющих структур, не нарушают их структурированности и корректности. Любых сложности и размера программы можно получать на основе соответствующего сочетания расширенного базиса (следование, ветвление, цикл, вызовы функций и механизм процедур) управляющих структур. Такой подход позволяет отказаться в программах от использования меток и безусловных переходов. Структура подобных программ четко прослеживается от начала (сверху) и до конца (вниз) при отсутствии передач управления на верхние уровни. Именно в свете сказанного Maple-язык представляет собой достаточно хороший пример лингвистического обеспечения при разработке эффективных структурированных программ, сочетающего лучшие традиции структурно-модульной технологии с ориентацией на математическую область приложений и массу программистски непрофессиональных пользователей из различных прикладных областей, включая и не совсем математической направленности. Для дальнейшего изложения напомним, что под «предложением» в Maple-языке понимается конструкция следующего простого вида:

<Maple-выражение> {;|:}

где в качестве выражения допускается любая корректная с точки зрения языка конструкция, например: A:= sqrt(60 + x): evalb(42 <> 64); sin(x) + x; `Tallinn-2006`:= 6; # Вызов и др. В рассмотренных ниже иллюстративных фрагментах приведено достаточно много различных примеров относительно несложных предложений в рамках управляющей структуры следования, которая достаточно прозрачна и особых пояснений не требует. Предложения кодируются друг за другом, каждое в отдельной строке или в одной строке несколько; завершаются в общем случае {;|:}-разделителями и выполняются строго последовательно, если управляющие структуры ветвления и цикла не определяют другого порядка. В дальнейшем предложения языка будем называть в соответствии с их определяющим назначением, например предложение присваивания, вызова функции, комментария, while-предложение, restart-предложение, if-предложение и т.д. Сделаем лишь одно замечание к предложению присваивания.

Наиболее употребительно определение предложения присваивания посредством одноименного (:=)-оператора, допускающего множественные присвоения. Однако, в целом ряде случаев вычислительные конструкции не допускают его использования. И в этом случае можно успешно использовать следующую процедуру Maple-языка: assign(Id{,|=} <Выражение>)

возвращающую NULL-значение (т.е. ничего) и присваивающую Id-идентификатору вычисленное выражение (которое, начиная с Maple 7, можеть быть и NULL). При этом, процедура assign в качестве единственного фактического аргумента допускает и список/множество уравнений вида Id = <Выражение>, определяющих соответствующие множественные присваивания. Например, списочная структура следующего фрагмента допустима лишь с использованием вышеупомянутой assign-процедуры пакета:

Первый пример фрагмента иллюстрирует недопустимость использования (:=)-оператора, а три последующих - реализацию этой же списочной структуры на основе процедуры assign. При этом последний пример фрагмента демонстрирует использование невычисленных идентификаторов, обеспечивающих корректность вычислений. Тогда как 3-й пример иллюстрирует ошибочность повторного применения assign для переопределения вычисленных переменных. В дальнейшем assign-процедура широко используется в иллюстративных примерах, а в книге [103] представлен ряд полезных ее расширений.

2.2. Управляющие структуры ветвления Mapleязыка (if-предложение)

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

(1) if <ЛУ> then <ПП> end if {;|:}

(2) if <ЛУ> then <ПП1> else <ПП2> end if {;|:}

(3) if <ЛУ1> then <ПП1> elif <ЛУ2> then <ПП2> else <ПП3> end if {;|:}

(4) `if`(<ЛУ>, V1, V2)

В качестве логического условия (ЛУ) всех четырех форматов if-предложения выступает любое допустимое булевское выражение, образованное на основе операторов отношения {<|<=|>| >=|=|<>}, логических операторов {and, or,not} и логических констант {true, false, FAIL}, и возвращающее логическое {true|false}-значение. Последовательность предложений (ПП) представляет собой управляющую структуру типа следования, предложения которой завершаются {;|:}-разделителем; для последнего предложения ПП кодирование разделителя необязательно. Во всех форматах, кроме последнего, ключевая фраза `end if` определяет закрывающую скобку (конец) if-предложения и его отсутствие идентифицирует синтаксическую ошибку, вид которой определяется контекстом if-предложения. Каждому if-слову должна строго соответствовать своя закрывающая скобка `end if`.

Первый формат if-предложения несет следующую смысловую нагрузку: если результат вычисления ЛУ возвращает true-значение, то выполняется указанная за ключевым thenсловом ПП, в противном случае выполняется следующее за if предложение, т.е. if-предложение эквивалентно пустому предложению. При этом, если if-предложение завершается (;)-разделителем, то выводятся результаты вычисления всех предложений, образующих ПП, независимо от типа завершающего их {:|;}-разделителя. Следовательно, во избежание вывода и возврата излишней промежуточной информации, завершать if-предложение рекомендуется (:)-разделителем.

Второй формат if-предложения несет следующую смысловую нагрузку: если результат вычисления ЛУ возвращает true-значение, то выполняется указанная за ключевым thenсловом ПП1, в противном случае выполняется следующая за ключевым else-словом ПП2. Замечание относительно вывода промежуточных результатов для случая первого формата if-предложения сохраняет силу и для второго формата кодирования.

ПП1, если evalb(ЛУ1) ⇒ true

ПП2, если (evalb(ЛУ1) ⇒ false)and(evalb(ЛУ2) ⇒ true)

R =^ ПП==========3, если (==========evalb(ЛУ1) ==========⇒ false)and==========(evalb(ЛУ2) ==========⇒ false)and==========(evalb(ЛУ3)======= ⇒ true)

ППn - 1, если (∀k |k ≤ n- 2)(evalb(ЛУk) ⇒ false)and(evalb(ЛУn - 1) ⇒ true)

ППn, in other cases

Третий формат if-предложения несет смысловую нагрузку, легко усматриваемую из общей R-функции, поясняющей принцип выбора выполняемой ППк в зависимости от цепочки истинности предшествующих ей ЛУj (j = 1 .. k) в предложении (см. выше).

А именно: if-предложение третьего формата возвращает R-результат выполнения ППк тогда и только тогда, когда справедливо следующее определяющее соотношение:

(∀j|j ≤ k-1) (evalb(ЛУj) ⇒ false) and (evalb(ЛУk) ⇒ true)

Данный формат if-предложения является наиболее общим и допускает любой уровень вложенности. Ключевое elif-слово является сокращением от “else if”, что позволяет не увеличивать число закрывающих скобок `end if` в случае вложенности if-предложения.

Наконец, по четвертому формату if-предложения возвращается результат вычисления V1-выражения, если evalb(<ЛУ>) ⇒ true, и V2-выражения в противном случае. Данный формат if-предложения подобно вызову Maple-функции можно использовать в любой конструкции, подобно обычному Maple-выражению, либо отдельным предложением. Следующий фрагмент иллюстрирует применение четырех форматов if-предложения:

> if (64 <> 59) then V:= 42: G:= 47: S:= evalf(sqrt(G - V), 6) end if: S; ⇒ 2.23607

> x:= 57: if type(x,'prime') then y:=x^2-99: z:=evalf(sqrt(y)) else NULL end if; y+z; ⇒ y + z > if (64 = 59) then V:= 42 else G:= 47: S:=evalf(sqrt(57 - G), 6) end if: [V, S]; ⇒ [42, 3.16228] > if (64 = 59) then V:= 42 elif (64 <= 59) then G:= 47 elif (39 >= 59) then S:= 67 elif (9 = 2) then Art:= 17 else `ArtVGS` end if; ⇒ ArtVGS

> AGN:= `if`(64 <> 59, 59, 64): Ar:= sqrt(621 + `if`(10 < 17, 2, z)^2): [AGN, Ar]; ⇒ [59, 25]

> if (64 = 59) then H:= `if`(3 <> 52, 52, 57) elif (57 <= 52) then H:= `if`(57 <> 52, 52, 57) elif

(32 >= 52) then S:= 67 elif (10 = 3) then Art:= 17 else `ArtVGS` end if; ⇒ ArtVGS

> V:= 64: G:= 59: if (V <> G) then S:= 39; if (V = 64) then Art:= 17; if (G = 59) then R:= G + V end if end if end if; ⇒ S := 39 > [%, S, Art, R]; ⇒ [123, 39, 17, 123]

> F:=x -> `if`(x < 39, S(x), `if`((39<=x) and (x<59), G(x), `if`((59<=x) and (x<64), V(x), Z(x)))): > [F(25), F(50), F(55), F(60), F(95), F(99)]; ⇒ [39, 59, 59, 64, Z(95), Z(99)]

Последний пример фрагмента иллюстрирует использование четвертого формата if-предложения для определения кусочно-определенной функции. Описание допустимых конструкций в качестве ЛУ и ПП для if-предложения обсуждалось выше, там же приведен целый ряд примеров по его применению. Ниже будет дана его дальнейшая детализация в контексте различного назначения иллюстративных фрагментов Maple-языка.

Синтаксис Maple-языка допускает также if-предложения следующего формата:

if <ЛУ1> then if < ЛУ2> then ... if <ЛУn> then <ПП> end if end if ... end if {;|:}

ЛУk - логические условия и ПП - последовательность предложений. Данного формата ifконструкция выполняется корректно, но результат возвращается без вывода. Его можно использовать по {%|%%|%%%}-предложению или по переменной, которой он был присвоен зараннее, как это иллюстрирует следующий простой фрагмент:

> V:=64: G:=59: if (V<>G) then if (V=64) then if (G=59) then R:= G+V end if end if end if;

> [%, R]; ⇒ [123, 123]

> if (V<>G) then S:=39; if (V=64) then Art:= 17; if (G=59) then R:=G+V end if end if end if;

S := 39

> [%, S, Art, R]; ⇒ [123, 39, 17, 123]

Последний пример фрагмента иллюстрирует существенно более широкую трактовку допустимости if-конструкций указанного формата и особенности их выполнения. Следует иметь в виду, что if-предложение возвращает {true|false}-значение даже в случае неопределенного по сути своей результата вычисления логического условия, например:

> [[a, b], `if`(eval(a) <> eval(b), true, false)]; ⇒ [[a, b], true]

> `if`(FAIL = FAIL, true, false); ⇒ true

С другой стороны, как иллюстрирует последний пример фрагмента, if-предложение отождествляет FAIL-значения, сводя различные неопределенности к единой, что также не соответствует здравому смыслу. Однако, причина этого лежит не в самом if-предложении, а в трактовке языком неопределенности, которая обсуждалась нами детально в [12].

Предложение if представляет собой наиболее типичное средство обеспечения ветвящихся алгоритмов. В этом контексте следует отметить, что аналогичное предложение Mathязыка пакета Mathematica [6,7] представляется нам существенно более выразительным, позволяя проще описывать ветвящиеся алгоритмы [33,39,41,42].

Наконец, Maple-язык допускает использование и безусловных переходов на основе встроенной функции goto, кодируемой в виде goto(<Метка>). Данная функция по вполне понятным причинам, обусловленным структурным подходом к программированию, недокументирована. Однако, в целом ряде случаев использование данного средства весьма эффективно, например, при необходимости погрузить в Maple-среду программу, использующую безусловные переходы на основе goto-предложения. Типичным примером являются Fortran-программы, широко распространенные в научных приложениях. Из нашего опыта следует отметить, что использование функции goto существенно упростило погружение в Maple целого комплекса физико-технических Fortran-программ, использующих goto-конструкции. Между тем, goto-функция имеет смысл только в теле процедуры, обеспечивая в точке вызова goto(<Метка>) переход к Maple-предложению, перед которым установлена указанная Метка. При этом, в качестве метки выступает некоторый идентификатор, как это иллюстрирует следующий простой фрагмент:

При использовании вызовов goto(<Метка>) следует иметь в виду, что Метка является глобальной переменной, что предполагает ее выбор таким образом, чтобы она не пересекалась с переменными текущего сеанса, находящимися вне тела процедуры, использующей goto-переходы. Нами была определена процедура isplabel [41,103], использующая простой подход защиты goto-меток, который состоит в следующем. Если процедура использует, например, метки L1, L2, ..., Ln, то в начале исходного текста процедуры кодируется вызов unassign('L1', 'L2', ..., 'Ln'). Это позволяет обеспечивать ошибкоустойчивость всех меток процедуры. Однако данный подход требует определенной уверенности, что отмена значения L-метки не будет отрицательно сказываться на выполнении документа текущего сеанса, если он использует одноименную переменную L вне тела процедуры. Процедура uglobal [103] позволяет в Maple-процедуре работать с глобальными переменными, не заботясь о возможности нежелательных последствий такого решения на глобальном уровне текущего сеанса пакета. Детальнее вопросы использования goto-функции Maple-языка и средства, сопутствующие ее использованию, рассматриваются в рамках нашей Библиотеки [103]. Рассмотрев средства организации ветвления вычислительного алгоритма, переходим к средствам организации циклических конструкций в среде языка пакета Maple.

2.3. Циклические управляющие структуры Mapleязыка (while_do-предложение)

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

(1.a) for <ПЦ> in <Выражение> while <ЛУ> do <ПП> end do {;|:}

(1.b) for <ПЦ> in <Выражение> do <ПП> end do {;|:}

(1.c) in <Выражение> while <ЛУ> do <ПП> end do {;|:}

(1.d) in <Выражение> do <ПП> end do {;|:}

(1.e) do <ПП> end do {;|:}

(2.a) for <ПЦ> from <A> by <B> to <C> while <ЛУ> do <ПП> end do {;|:}

(2.b) for <ПЦ> from <A> to <C> while <ЛУ> do <ПП> end do {;|:}

(2.c) for <ПЦ> from <A> while <ЛУ> do <ПП> end do {;|:}

(2.d) for <ПЦ> while <ЛУ> do <ПП> end do {;|:}

(2.e) while <ЛУ> do <ПП> end do {;|:}

Наиболее общего вида вариант (1.а) первого формата while_do-предложения несет следующую смысловую нагрузку: для заданной переменной цикла (ПЦ), принимающей в качестве значений значения последовательных операндов указанного после in-слова выражения, циклически повторяется вычисление последовательности предложений (ПП), ограниченной скобками {do ….. end do}, до тех пор, пока логическое условие (ЛУ) возвращает true-значение (см. прилож. 3 [12]). В качестве выражения, как правило, выступают список, множество и диапазон, тогда как относительно ЛУ имеет место силу все сказанное для случая if-предложения. При этом, значения операндов, составляющих выражение, могут носить как числовой, так и символьный характер. Сказанное в адрес if-предложения относится и к типу используемого для предложения while_do завершающего его {;|:}-разделителя.

После завершения while_do-предложения управление получает следующее за ним предложение. Смысл вариантов (1.b..1.d) первого формата while_do-предложения с учетом сказанного достаточно прозрачен и особых пояснений не требует. Следующий простой фрагмент иллюстрирует принципы выполнения всех вариантов первого формата предложения while_do по организации циклических вычислений:

Первый формат while_do-предложения

> x:= 1: for k in {10, 17, 39, 44, 59, 64} while (x <=4 ) do printf(`%s%a, %s%a, %s%a|`, `k=`, k, `k^2=`, k^2, `k^3=`, k^3); x:= x + 1 end do:

k=10, k^2=100, k^3=1000|k=17, k^2=289, k^3=4913|k=39, k^2=1521, k^3=59319|k=44, k^2=1936, k^3=85184|

> for k in (h$h=1 .. 13) do printf(`%a|`, k^2) end do:

1|4|9|16|25|36|49|64|81|100|121|144|169|

> k:= 0: in (h$h=1 .. 99) while (not type(k, 'prime')) do k:=k+1: printf(`%a|`, k^2) end do:

1|4|

Несколько пояснений следует сделать относительно варианта (1.e) первого формата, который в общем случае определяет бесконечный цикл, если среди ПП не определено программного выхода из него или не производится внешнего прерывания по stop-кнопке 3й строки GUI. В общем же случае для обеспечения выхода из циклической конструкции служит управляющее break-слово, в результате вычисления которого производится немедленный выход из содержащей его конструкции с передачей управления следующему за ней предложению. В случае вложенных циклов передача управления производится циклу, внешнему относительно break-содержащего цикла.

Тогда как по next-слову производится переход к вычислению циклической конструкции со следующим значением переменной цикла. Лучше всего различие управляющих значений break и next иллюстрируют простые примеры нижней части предыдущего фрагмента. Из них легко заметить, что если break-значение обеспечивает немедленный выход из цикла, в котором оно было вычислено, с передачей управления следующему за ним предложению илио внешнему относительно его циклу, то next-значение позволяет управлять счетчиком выполнения цикла, обеспечивая выбор очередного значения для переменной цикла без выполнения самого тела цикла, т.е. обеспечивается условное выполнение цикла. Так, в упомянутом выше фрагменте цикл, содержащий break-значение (1), завершается по мере встречи первого нечетного числа, тогда как для аналогичного цикла (2), содержащего next-значение, цикл выполняется полностью, но N-множество, в отличие от М-множества предыдущего цикла, формируется только из к-чисел списка, для которых значения к/2 являются четными. Наконец, пример (3) фрагмента иллюстрирует совместное использование для управления циклической конструкцией варианта (1.e) первого формата while_do-предложения управляющих значений next и break с целью оценки производительности ПК, работающего под управлением системы DOS+Windows + Maple 8, в единицах простых операций в с. Для обеспечения возможности последующего использования результатов выполнения циклических конструкций в их телах можно предусматривать аккумуляцию и сохранение результатов, получая возможность доступа к ним после завершения (даже в целом ряде случаев ошибочного или аварийного) выполнения циклической конструкции.

Наряду с численными первый формат while_do-предложения позволяет весьма успешно производить и символьные вычисления и обработку, так в частности, пример (4) предыдущего фрагмента иллюстрирует эквивалентную замену map-функции соответствующей циклической конструкцией и некоторые другие полезные преобразования.

Наиболее общего вида вариант (2.а) второго формата while_do-предложения несет следующую смысловую нагрузку: для заданной переменной цикла (ПЦ), принимающей в качестве значений последовательность значений A, A+B, A+2*B, ..., A+n*B ≤ C (где А,В,С - результаты вычисления соответствующих выражений), циклически повторяется вычисление последовательности предложений (ПП), ограниченной скобками {do….end do}, до тех пор, пока логическое условие (ЛУ) возвращает true-значение. В качестве А, В, С, как правило, выступают целочисленные выражения, тогда как относительно ЛУ имеет место силу все сказанное для случая if-предложения. Это же относится и к типу завершающего разделителя, используемого для предложения второго формата.

В случае отсутствия во втором формате while_do-предложения ключевых слов {from, by} для них по умолчанию полагаются единичные значения. Для С-выражения второго формата, стоящего за to-словом, допускается infinity-значение, однако в этом случае во избежание зацикливания (бесконечного цикла) необходимо определять условия завершения (или выхода из) цикла в ЛУ и/или в ПП. Минимально допустимым форматом while_doпредложения в Maple-языке является конструкция do ... end do {;|:}, определяющая собой пустой бесконечный цикл, на основе которого можно программировать не только различного рода программные задержки (как это показано в примере (5) последнего фрагмента), но и создавать различной сложности вычислительные конструкции вида do ... <ПП> end do, решающие циклического характера задачи с обеспеченным определенным выходом из них. В этом смысле (do...end do)-блок можно рассматривать в качестве тела любой циклической конструкции, управление режимом выполнения которой производится через управляющую оболочку типов for_from .... to_while и for_in_while.

Между тем, стандартные for_while_do-конструкции допускают только фиксированный уровень вложенности (вложенные циклы), тогда как в целом ряде приложений уровень вложенности определяется динамически в процессе выполнения алгоритма. В состав нашей Библиотеки [103] включена процедура FOR_DO, обеспечивающая работу с динамически генерируемыми конструкциями for_while_do любого конечного уровня вложенности.

Процедура FOR_DO обеспечивает динамическую генерацию «for_do»-конструкций следующих достаточно широко используемых типов, а именно:

(1) for k1 to M do Expr[k1] end do; [k1, M]

(2) for k2 by step to M do Expr[k2] end do; [k2, step, M]

(3) for k3 from a by step to M do Expr[k3] end do; [k3, a, step, M]

(4) for k4 in M do Expr[k4] end do; [k4, `in`, M]

Вызов процедуры FOR_DO принимает следующий вид (подробности см. в [41,103,109]):

FOR_DO([k1,M],[k2,step,M],[k3, `in`, M],[k4,a,step,M],…, [kp,…],"Expr[k1,k2,k3, …, kp]")

2.4. Специальные типы циклических управляющих структур Maple-языка пакета

Наряду с рассмотренными базовыми Maple-язык располагает рядом специальных управляющих структур циклического типа, позволяющих существенно упрощать решение целого ряда важных прикладных задач. Такие структуры реализуются посредством ряда встроенных функций и процедур {add, mul, seq, sum, product, map, member и др.}, а также $-оператора, позволяющих компактно описывать алгоритмы массовых задач обработки и вычислений. При этом, обеспечивается не только большая наглядность Mapleпрограмм, но и повышенная эффективность их выполнения. Следующий фрагмент иллюстрирует результаты вызова некоторых из перечисленных средств с эквивалентными им конструкциями Maple-языка, реализованными посредством базовых управляющих структур следования, ветвления и циклических.

> add(S(k), k=1..10); ⇒ S(1) + S(2) + S(3) + S(4) + S(5) + S(6) + S(7) + S(8) + S(9) + S(10)

> assign('A'=0); for k from 1 to 5 do A:=A+F(k) end do: A; ⇒ F(1) + F(2) + F(3) + F(4) + F(5)

> mul(F(k), k=1..13); ⇒ F(1) F(2) F(3) F(4) F(5) F(6) F(7) F(8) F(9) F(10) F(11) F(12) F(13)

> assign('M'=1); for k from 1 to 7 do M:=M*F(k) end do: M; ⇒ F(1) F(2) F(3) F(4) F(5) F(6) F(7)

> seq(F(k), k=1..12); ⇒ F(1), F(2), F(3), F(4), F(5), F(6), F(7), F(8), F(9), F(10), F(11), F(12)

> assign('S'=[]); for k from 1 to 5 do S:=[op(S),F(k)] end do:op(S); ⇒ F(1), F(2), F(3), F(4), F(5)

> map(F, [x1,x2,x3,x4,x5,x6,x7,x8]); ⇒ [F(x1), F(x2), F(x3), F(x4), F(x5), F(x6), F(x7), F(x8)]

> assign('m'=[]); for k in [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10] do m:=[op(m),F(k)] end do: m;

[F(x1), F(x2), F(x3), F(x4), F(x5), F(x6), F(x7), F(x8), F(x9), F(x10)]

> L:= [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]: member(x3, L); ⇒ true

> for k to nops(L) do if L[k]=x10 then R:=true: break else R:=false end if end do: R; ⇒ true

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

> G:= [59, 64, 39, 44, 10, 17]: add(G[k]*`if`(type(G[k], 'odd'), 1, 0), k=1..nops(G)); ⇒ 115

> mul(G[k]*`if`(type(G[k], 'even'), 1, `if`(G[k]=0, 1, 1/G[k])), k=1..nops(G)); ⇒ 28160

> F:=[10,GS,17]: (seq(F[k]*`if`(type(F[k],‘symbol’),1,0),k=1..nops(F)))(x,y,z); ⇒ 0, GS(x,y,z), 0 > (seq(`if`(type(F[k], 'symbol'), true, false) and F[k], k=1..nops(F))); ⇒ false, GS, false

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

В циклических конструкциях типа `for k in n$n=a..b...` не допускается отождествления идентификаторов k и n, не распознаваемого синтаксически, но приводящего к ошибкам выполнения конструкции. Более того, в общем случае нельзя отождествлять в единой конструкции переменные цикла и суммирования/произведения, например:

> h:= 0: for k to 180 do h:= h + sum(1, k = 1 .. 64) end do; h; ⇒ 0

Error, (in sum) summation variable previously assigned, second argument evaluates to 1 = 1 .. 64

> h:= 0: for k to 180 do h:= h + sum(1, 'k' = 1 .. 64) end do: h; ⇒ 11520

> h:= 0: for k to 180 do h:= h + product(1, k = 1 .. 64) end do: h; ⇒ 0

Error, (in product) product variable previously assigned, second argument evaluates to 1 = 1 .. 64 > h:= 0: for k to 180 do h:= h + product(2, 'k' = 1 .. 64) end do: h;

3320413933267719290880

> h:= 0: for k in ['k' $ 'k'=1..64] do h:= h + k end do: h; ⇒ 2080

> h:= 0: for k in [k $ 'k'=1 .. 64] do h:= h + k end do: h; ⇒ 4096

> h:= 0: for k in [k $ k=1 .. 64] do h:= h + k end do: h; ⇒ 0

Error, wrong number (or type) of parameters in function $

Вместе с тем, как иллюстрирует фрагмент, корректность выполняется при кодировании переменной суммирования/произведения в невычисленном формате. Более того, три последних примера фрагмента иллюстрируют как допустимость, так и корректность использования общей переменной внешнего цикла и циклической $-конструкции, но при условии использования последней в невычисленном формате. Данное обстоятельство определяется соглашениями Maple-языка по использованию глобальных и локальных переменных, детально рассматриваемых в следующей главе книги, посвященной процедурным объектам языка.

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

> S:="aqwertyuopsdfghjkzxc": R:=convert(S,'bytes'): convert([R[k]],'bytes') $ k=1..nops(R); Error, byte list must contain only integers

> cat(seq(convert([R[k]], 'bytes'), k = 1 .. nops(R))); ⇒ "aqwertyuopsdfghjkzxc"

> X,Y:=99,95: seq(H(k),k=`if`(X<90,42,95)..`if`(Y>89,99,99)); ⇒ H(95),H(96),H(97),H(98),H(99)

Таким образом, оба, на первый взгляд, эквивалентные средства формирования последовательностных структур следует применять весьма осмотрительно, по возможности отдавая предпочтение первому, как наиболее универсальному. В этом отношении для seqфункции имеют место (в ряде случаев весьма полезные) следующие соотношения: seq(A(k), k = [B(x)]) ≡ seq(A(k), k = {B(x)}) ≡ (A@B)(x) ≡ A(B(x)) seq(A(k), k = x) ≡ seq(A(k), k = B(x)) ≡ A(x)

При использовании `if`-функции для организации выхода из циклических конструкций рекомендуется проявлять внимательность, ибо возвращаемое функцией break-значение не воспринимается в качестве управляющего слова Maple-языка пакета, например:

> R:= 3: do R:= R - 1; if R= 0 then break end if end do: R; ⇒ 0

> R:= 3: do R:= R-1; `if`(R=0, `break`, NULL) end do: R; ⇒ 0

Error, invalid expression

Первый пример фрагмента иллюстрирует успешный выход из do-цикла по достижении R-переменной нулевого значения и удовлетворения логического условия if-предложения. Тогда как второй пример показывает невозможность выхода из идентичного do-цикла на основе `if`-функции, возвращающей на значении R=0 break-значение, не воспринимаемое в качестве управляющего слова. При этом, если в Maple 7–10 инициируется ошибочная ситуация, то еще в Maple 6 второй пример, не вызывая ошибочной ситуации, выполняет бесконечный цикл, требуя прекращения вычислений по stop-кнопке GUI. В случае использования вместо break функций done, quit и stop выполняется бесконечный цикл, требуя прекращения вычислений по stop-кнопке GUI.

Циклические вычислительные конструкции можно определять и на основе функций {select, remove}, имеющих следующий единый формат кодирования:

{select|remove}(<ЛФ>, <Выражение> {, <Параметры>})

Результатом вызова select-функции является объект того же типа, что и ее второй фактический аргумент, но содержащий только те операнды выражения, на которых логическая функция (ЛФ) возвращает true-значение. Третий необязательный аргумент функции определяет дополнительные параметры, передаваемые ЛФ. В качестве выражения могут выступать список, множество, сумма, произведение либо произвольная функция. Функция remove является обратной к select-функции. Следующий простой фрагмент иллюстрирует применение функций select и remove для циклических вычислений:

> select(issqr, [seq(k, k= 1 .. 350)]);

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324]

> ЛФ:= x ->`if`(x >= 42 and x <= 99, true, false): select(ЛФ, [seq(k, k = 1 .. 64)]);

[42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]

> remove(ЛФ, [seq(k, k = 1 .. 64)]); ⇒ [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]

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

В целом ряде случаев работы с данными индексированного типа {array, Array и др.} возникает необходимость динамической генерации вложенных циклических конструкций, когда уровень циклической вложенности заранее неизвестен и вычисляется программно. В этом случае может оказаться весьма полезной процедура SEQ [41,103]. Процедура обеспечивает динамическую генерацию seq-конструкций следующего типа:

seq(expr[k], k = a .. b) и seq(expr[k], k = V)

Следующий пример иллюстрирует применение SEQ-процедуры:

> SG:= Array(1..2, 1..3, 1..4): SEQ([k, 1..2], [j, {1, 2, 3}], [h, 2..3], "assign('SG'[k,j,h]=k+j+h)"); ArrayElems(SG);

{(1, 1, 2) = 4, (1, 1, 3) = 5, (1, 2, 2) = 5, (1, 2, 3) = 6, (1, 3, 2) = 6, (1, 3, 3) = 7, (2, 1, 2) = 5,

(2, 1, 3) = 6, (2, 2, 2) = 6, (2, 2, 3) = 7, (2, 3, 2) = 7, (2, 3, 3) = 8}

Используемый процедурой прием может быть использован для расширения других циклических конструкций [41,103]. Детальнее группа функциональных средств, объединенных управляющей структурой циклического типа, на семантическом уровне рассматривалась выше. Здесь же на нее было акцентировано внимание именно в связи с вопросом механизма организации управляющих структур Maple-языка.

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

Глава 3. Организация механизма процедур в Maple-языке пакета

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

Решение данной задачи можно обеспечивать двумя основными путями: (1) исчерпывающее тестирование готового программного средства (ПС), устранение всех ошибок и оптимизация его по заданным критериям; и (2) обеспечение высокого качества на всех этапах разработки ПС. Так как для большинства достаточно сложных ПС первый подход неприемлим, то наиболее реальным является второй, при котором вся задача разбивается на отдельные объекты (модули), имеющие хорошо обозримые структуру и функции, относительно небольшие размеры и сложность и структурно-функциональное объединение (композиция) которых позволяет решать исходную задачу. При таком модульном подходе сложность ПС редуцируется к существенно меньшей сложности составляющих его компонент, каждая из которых выполняет четкие функции, обеспечивающие в совокупности с другими компонентами требуемое функционирование ПС в целом. Метод программирования, когда вся программа разбивается на группы модулей, каждый со своей контролируемой структурой, четкими функциями и хорошо определенным интерфейсом с внешней средой, называется модульным программированием.

Поскольку модульный является единственной альтернативой монолитного (в виде единой программы) подхода, то вопрос состоит не в целесообразности разбивать или нет большую программу на модули, а в том - каков должен быть критерий такого разбиения. На сегодня практика программирования знает и использует целый ряд методов организации многомодульных ПС, когда разбиение на модули основывается на их объемных характеристиках в строках исходного текста, выделении однотипных операций и т.д. Однако наиболее развитым представляется критерий, в основе которого лежит хорошо известный принцип «черного ящика». Данный подход предполагает на стадии проектирования ПС представлять его в виде совокупности функционально связанных модулей, каждый из которых реализует одну из допустимых функций. При этом, способ взаимодействия модулей должен в максимально возможной степени скрывать принципы его функционирования и организации. Подобная модульная организация приводит к выделению модулей, которые характеризуются легко воспринимаемой структурой и могут проектироваться и разрабатываться различными проектировщиками и программистами. Более важный аспект состоит в том, что многие требуемые модификации сводятся к изменению алгоритмов функционирования отдельных модулей без изменения общей структурно-функциональной организации ПС в целом. Вопросы современной концепции модульного программирования базируются на ряде основных предпосылок, рассматриваемых, например, в книгах [1-3] и в цитируемой в них весьма обширной литературе.

3.1. Определения процедур в Maple-языке и их типы

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

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

Процедура в среде Maple-языка имеет следующую принципиальную структуру: proc(<Последовательность формальных аргументов>){::Тип;} local <Последовательность идентификаторов>; Описательная global <Последовательность идентификаторов>; часть options <Последовательность параметров>; определения uses <Последовательность имен пакетных модулей>;

description <Описание>; процедуры

<Т Е Л О процедуры>

end proc {;|:}

Заголовок процедуры содержит ключевое proc-слово со скобками, в которых кодируется последовательность формальных аргументов процедуры; данная последовательность может быть и пустой, т.е. минимально допустимый заголовок процедуры имеет вид proc( ). Позади заголовка может кодироваться тип, относящийся к типу возвращаемого процедурой результата. Подробнее об этом говорится ниже. Ключевые слова local, global и options определяют необязательные описательные секции процедуры, представляющие соответственно последовательности идентификаторов локальных, глобальных переменных и параметров (опций) процедуры. Необязательная description-секция содержит последовательность строк, описывающих процедуру. Если данная секция представлена в определении процедуры, то она будет присутствовать и при выводе последней на печать. Практически все библиотечные процедуры пакета содержат description-секцию, хотя она и не выводится на печать. При этом, если данная секция содержит несколько предложений, то она должна кодироваться последней, иначе инициируется ошибочная ситуация, как это иллюстрирует нижеследующий простой фрагмент:

> P:= proc() description "Сумма аргументов"; `+`(args); `+`(args) end proc: print(P); proc() description "Сумма аргументов"; `+`(args); `+`(args) end proc

> P(42, 47, 67), op(5, eval(P)); ⇒ 156, "Сумма аргументов"

> P:= proc() description "Сумма аргументов"; `+`(args); `+`(args); option trace; end proc; Error, reserved word `option` or `options` unexpected

В Maple 10 дополнительно к указанным определение процедуры допускает использование необязательной uses-секции, определяющей имена пакетных модулей, используемых процедурой. Например, кодирование секции «uses LinearAlgebra» эквивалентно использованию в процедуре use-предложения следующего формата: use LinearAlgebra in < ... > end use;

Данная секция не идентифицируется при выводе либо возврате определения процедуры, исчезая подобно use-предложению, как это иллюстрирует следующий пример: > P:= proc() local a,b,c; global d; uses LinearAlgebra; option remember; description "grsu"; BODY end proc;

P := proc() local a, b, c; global d; option remember; description "grsu"; BODY end proc И не возвращается ее содержимое по вызовам op(k, eval(P)) (k=1..8) подобно случая других секций описания произвольной процедуры Р.

На наш взгляд, секция uses носит непринципиальный характер, в определенной мере лишь упрощая (сокращая) оформление процедуры, тогда как с точки зрения читабельности исходного текста использование в теле use-предложений даже более предпочтительно. Не говоря уже о том, что данное непринципиальное новшество ведет к несовместимости процедур «сверху-вниз» относительно релизов пакета.

Секции local, global, options, uses и description составляют описательную часть определения Maple-процедуры, которая в общем случае может и отсутствовать. Управлять выводом тела процедуры можно посредством установки переменной verboseproc interfaceпроцедуры Maple-языка. Минимальной конструкцией, распознаваемой ядром в качестве процедуры, является структура следующего весьма простого вида, а именно: Proc := proc() end proc: whattype(eval(Proc)); ⇒ procedure

Распознаваемый пакетом Proc-объект в качестве процедуры, между тем, особого смысла не имеет, ибо вызов процедуры Proc(args) на любом кортеже фактических аргументов всегда возвращает NULL-значение, т.е. ничего. Для возможности вызова процедуры ее определение присваивается некоторому Id-идентификатору Id := proc({ |Args}) ... end proc {:|;}, позволяя после его вычисления производить вызов процедуры по Id({|Args })конструкции с заменой ее формальных Args-аргументов на фактические Args -аргументы. Наряду с классическим определением именованной процедуры Maple-язык допускает использование и непоименованных процедур, определения которых не присваиваются какому-либо идентификатору. Для вызова непоименованных процедур служит конструкция следующего вида:

proc({ |Args}) ... end proc(Args )

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

> proc() [nargs, args] end proc(42, 47, 67, 89, 96, -2, 95, 99); ⇒ [8, 42, 47, 67, 89, 96, -2, 95, 99]

> proc(n) sum(args[k], k=2..nargs)^n end proc(3, x, y, z, a, b, c, h); ⇒ (x+y+z+a+b+c+h)³

> D(proc(y) (y^9 + 3*y^5 - 99)/6*(3*y^2 - 256) end proc)(9); ⇒ 2648753541

> a*proc(x) x^2 end proc(42) + b*proc(y) y^2 end proc(47); ⇒ 1764 a + 2209 b

> D(proc(y) (y^9 + 2*y^5 - 99)/13*(3*y^2 - 256) end proc);

proc(y) 1/13*(9*y^8+10*y^4)*(3*y^2-256)+6/13*(y^9+2*y^5-99)*y end proc

> restart: (D@@9)(proc(x) G(x) end proc); ⇒ proc(x) (D@@9)(G)(x) end proc

Непоименованные процедуры можно использовать в ряде выражений и обрабатывать некоторыми функциями и операторами, как это иллюстрируют примеры фрагмента. В этом смысле наиболее часто непоименованные процедуры используются в конъюнкции с функциями {map,map2}, а также с другими функциями и операторами, допускающими неалгебраические выражения в качестве своих фактических аргументов и операндов. В то же время, как правило, рекомендуется использовать именно именованные Maple-процедуры, что позволяет исключать различного рода ошибки.

Тело процедуры содержит текст описания алгоритма решаемой ею задачи с использованием рассмотренных выше средств Maple-языка, а именно: данных и их структур допустимых типов, переменных, функций пакетных, модульных и пользовательских, других процедур и т. д., логически связанных управляющими структурами следования, ветвления и цикла, рассмотренными выше. Данное описание должно удовлетворять правилам допускаемого языком синтаксиса. Завершается процедура кодированием закрывающей процедурной скобки `end proc`. Представленная структура является определением процедуры, которое активизируется только после его вычисления. При этом, во время вычисления процедуры не производится выполнения предложений тела процедуры, но интерпретатор Maple-языка производит все возможные упрощения тела процедуры, являющиеся простым типом ее оптимизации. Реальное же выполнение тела процедуры производится только в момент ее вызова с передачей ей фактических аргументов, значения которых замещают все вхождения в тело формальных аргументов. Завершается определение процедуры обязательным предложением `end proc {:|;}` (закрывающей скобкой).

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

(Args) -> <Выражение от Args-переменных>

При этом, в случае единственного аргумента кодирование его в скобках не обязательно. Присвоение данной конструкции идентификатору позволяет определить процедуру, например: > G:= (x, y) -> evalf(sqrt(x^2 + y^2)): G(42, 47); ⇒ 63.03173804. Последовательность формальных аргументов в таким образом определяемой процедуре может быть пустой, а ее тело должно быть единым выражением либо if-предложением языка:

При этом, следует иметь в виду, что второй способ определения предназначен, прежде всего, для простых однострочных процедур и функций, ибо не поддерживает механизма локальных и глобальных переменных, а также опций. Между тем, в целом ряде случаев он оказывается весьма полезным приемом программирования. Подобно первому способу определения процедур, второй также допускает использование непоименованных процедур, используемых в тех же случаях, что и первый способ. Как это иллюстрируют последние примеры предыдущего фрагмента (см. прилож. 3 [12]).

Наконец, третий способ определения однострочных простых процедур базируется на использовании define-процедуры, имеющей для этого формат кодирования вида: define(F, F(x1::<Тип_1>, ..., xn::<Тип_n>) = <Выражение>(x1, ..., xn))

По этому формату define-процедура в качестве F-процедуры/функции от типированных (x1, ..., xn)-аргументов/переменных определяет выражение от этих же ведущих переменных. При этом, допускается использование не только типов, идентифицируемых typeфункцией, но и структурных типов. Фактические аргументы, определяемые их типированными формальными аргументами, могут принимать любые совместимые с указанными для них типами значения. Успешный вызов процедуры define возвращает NULL-значение. Вызов определенной таким образом процедуры/функции производится по конструкции F(x1,..., xn). Следующий фрагмент иллюстрирует применение define-процедуры для определения пользовательских процедур:

Второй пример фрагмента иллюстрирует вид исходного текста процедуры G, генерируемой пакетом по define-процедуре. В случае передачи определенной по define процедуре некорректных фактических аргументов (несоответствие числа фактических аргументов формальным и/или их типов) ее вызов возвращается невычисленным, как это иллюстрирует третий пример фрагмента. При этом, если определенная первым способом процедура допускает корректное выполнение в случае превышения числа фактических аргументов над формальными (игнорируя лишние), то в случае определенной третьим способом данная ситуация полагается ошибочной, возвращая вызов невычисленным. Напоминая второй способ определения процедур, третий отличается от него существенным моментом, позволяя использовать типизацию формальных аргументов. Между тем, третий способ определения процедур имеет определенные ограничения, не позволяя использовать в теле процедуры произвольные Maple-функции. Так, третий пример фрагмента иллюстрирует некорректность вызова определенной третьим способом S-процедуры (в ее теле использована cat-функция), тогда как определения эквивалентных ей процедур первым и вторым способом возвращают вполне корректные результаты. Следовательно, третий способ следует использовать весьма осмотрительно.

Подобным третьему способом определения пользовательской функции является применение специальной unapply-процедуры, имеющей следующий формат кодирования: unapply(<Выражение> {, <Ведущие переменные>})

где выражение определяет собственно тело самой функции, а ведущие переменные – последовательность ее формальных аргументов. В результате своего вызова unapply-процедура возвращает рассмотренную выше функциональную конструкцию в терминах (->)-оператора, как это иллюстрирует следующий весьма простой фрагмент:

Реализация unapply-процедуры базируется на использовании λ-исчисления, а сама процедура применяется, как правило, при использовании вычисляемых выражений для функциональных конструкций. Эта же процедура позволяет достаточно эффективно производить функциональные определения и в рамках структур (список, множество, массив). В наиболее же массовых случаях определения пользовательских функций оба представленных средства функциональный (->)-оператор и unapply-процедуру можно полагать эквивалентными, хотя в общем случае и имеются существенные различия.

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

Первый пример фрагмента представляет SV-функцию от неопределенного числа формальных аргументов, определенную на основе unapply-процедуры, а второй - VS-функцию, определенную на основе функционального (->)-оператора и эквивалентную (по реализованному алгоритму) SV-функции. Вместе с тем, как иллюстрируют примеры фрагмента, между обоими определениями имеется существенное различие, а именно: игнорируется ряд встроенных функций (evalf, convert) при определении SV-функции. Поэтому, в общем случае способ определения функции на основе функционального (->)-оператора является более универсальным.

Следует отметить, что представленный способ определения пользовательской функции на основе define-процедуры по целому ряду характеристик предпочтительнее способа, базирующегося на функциональном (->)-операторе или unapply-процедуре, как это иллюстрирует следующий весьма поучительный фрагмент:

Фрагмент иллюстрирует реакцию пакета на переопределения функции, определенной на основе define-подхода, и вызовы пользовательской H-функции от двух типированных аргументов. На примере H-функции проиллюстрированы следующие два весьма принципиальных момент, а именно:

(1) результат вызова define-определенной функции в общем случае требует последующей обработки evala-функцией для получения окончательного результата;

(2) вызов define-определенной функции на фактических аргументах, не отвечающих оп- ределенным для них типам, возвращается невычисленным.

Использование последовательности свойств позволило определить целочисленную рекуррентную AG-функцию. Пример определения G3-функции иллюстрирует возможность использования специальных переменных args, nargs в define-определении функции, тогда как пример G4-функции дополнительно иллюстрирует определение функции от неопределенного числа аргументов. Однако, при этом следует иметь в виду, что использование указанных переменных в define-определении функций носит более ограниченный характер, чем при других способах определения функций пользователя. Более того, как показывают примеры определения двух эквивалентных функций G6 и G7, в плане представимости типов выражений, используемых при определении функции, функциональный (->)-оператор более предпочтителен. Примеры определения функций G8 и G9 также иллюстрируют ограничения define-способа задания функций. В этом отношении следует отметить, что реализация define-функции более младших релизов Maple во многих отношениях была более эффективной [8-10]. Наконец, последний пример фрагмента иллюстрирует (в ряде случаев весьма полезную) возможность рекурсивного использования функции define для определения функций пользователя.

Использование assign-процедуры для присвоения определения функции некоторому идентификатору (ее имени) позволяет включать определения функций непосредственно в вычислительные конструкции, соблюдая только одно правило: вычисление определения функции должно предшествовать ее первому вызову в вычисляемом выражении. Сказанное относится к любому способу определения функции, например:

> assign(G1, unapply([nargs, sum(args['k'], 'k'=1..nargs)]));

> assign(G2, () -> [nargs, sum(args['k'], 'k'=1..nargs)]);

> define(G3, G3()= nargs*sum(args[k], 'k'=1..nargs)), G1(42,47,67,62,89,96),

G2(42,47,67,62,89,96), G3(42,47,67,62,89,96); ⇒ [6, 403], [6, 403], 2418

> assign(Kr, unapply([nargs, sum(args[p], 'p'=1..nargs)])), Kr(10, 17); ⇒ [2, 27]

В частности, последний пример фрагмента иллюстрирует вычисление списочной структуры, содержащей unapply-определение Kr-функции, с последующим ее вызовом. Следует отметить при этом, что механизм пользовательских функций, поддерживаемый пакетом Mathemaica [6, 7], представляется нам существенно более гибким при реализации алгоритмов обработки.

При этом следует иметь ввиду, что в случае определения процедуры в assign-конструкции ее определение становится глобальным, если ее имя не определено в local-секции содержащей конструкцию процедуры, как это иллюстрирует следующий фрагмент:

Еще об одном ухищрении стоит сказать особо. В релизах 6 и ниже по конструкции вида m(assign('a' = <Выражение>), где m – произволное целое либо NULL

можно было широко использовать assign-конструкции в выражениях, ибо возвращалось значение m с вычислением выражений в скобках, например:

> m:=10: (m(assign('a'=2006)) + a - 16)/(6(assign('b'=1995)) + b - 1); ⇒ 1 # Maple 6

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

> m:=10: (m(assign('a'=2006)) + a - 16)/(6(assign('b'=1995)) + b - 1); # Maple 7 – 10 − 6 + a

5 + b

Что породило еще один тип несовместимости релизов пакета «снизу-вверх» для тех, кто пытался использовать особенности Maple-языка при программировании своих задач.

Рассмотрев способы определения процедур в Maple-языке и их структурную организацию, обсудим более детально отдельные компоненты структуры процедур, определяемых первым способом, как наиболее универсальным и часто используемым. Это тем более актуально, что позволит вам не только понимать реализацию пакетных процедур и процедур нашей Библиотеки [41] (некоторые из них представлены и в настоящей книге), но и самому приступать к созданию собственных конкретных приложений в среде Maple, реализованных в форме процедур и их библиотек.

3.2. Формальные и фактические аргументы Mapleпроцедуры

Формальный аргумент процедуры в общем случае имеет вид <Id>::<Тип>, т. е. Id-идентификатор с приписанным ему типом, который не является обязательным. В случае определения типированного формального аргумента при передаче процедуре в момент ее вызова фактического аргумента, последний проверяется на соответствие типу формального аргумента. При несовпадении типов идентифицируется ошибочная ситуация с возвратом соответствующей диагностики. Совершенно иная ситуация имеет место при несовпадении числа передаваемых процедуре фактических аргументов числу ее формальных аргументов: (1) в случае числа фактических аргументов, меньшего определенного

для процедуры числа формальных аргументов, как правило, идентифицируется ошибочная ситуация типа “Error, (in Proc) Proc uses a nth argument <Id>, which is missing”, указывающая на то, что Proc-процедуре было передано меньшее число фактических аргументов, чем имеется формальных аргументов в ее определении; где Id - идентификатор первого недостающего n-го фактического аргумента; (2) в случае числа фактических аргументов, большего определенного для процедуры числа формальных аргументов, ошибочной ситуации не идентифицируется и лишние аргументы игнорируются. Между тем, и в первом случае возможен корректный вызов. Это будет в том случае, когда в теле процедуры не используются формальные аргументы явно. Следующий простой фрагмент хорошо иллюстрирует вышесказанное:

В момент вызова процедуры с передачей ей фактических выражений для ее соответствующих формальных аргументов первые предварительно вычисляются и их значения передаются в тело процедуры для замещения соответствующих им формальных аргументов, после чего производится вычисление составляющих тело Maple-предложений с возвратом значения последнего вычисленного предложения, если не было указано противного. В случае наличия в определении процедуры типированных формальных аргументов элементы последовательности передаваемых при ее вызове фактических значений проверяются на указанный тип и в случае несовпадения инициируется ошибочная ситуация, в противном случае выполнение процедуры продолжается. В качестве типов формальных аргументов процедуры используются любые из допустимых языком и тестируемых функцией type и процедурой whattype. При использования нетипированного формального аргумента рекомендуется все же указывать для него anything-тип, информируя других пользователей процедуры о том, что для данного формального аргумента допускаются значения любого типа, например, кодированием заголовка процедуры в виде proc(X::integer, Y::anything).

В качестве формальных аргументов могут выступать последовательности допустимых выражений Maple, типированных переменных, либо пустая последовательность. Типированная переменная кодируется в следующем формате: <Переменная>::<Тип>. Тип может быть как простым, так и сложным. При обнаружении в точке вызова процедуры фактического аргумента, типом отличающегося от определенного для соответствующего ему формального аргумента, возникает ошибочная ситуация с возвратом через lasterror-переменную соответствующей диагностики и с выводом ее в текущий сеанс, например:

> A:=proc(a::integer, b::float) a*b end proc: A(64, 42);

Error, invalid input: A expects its 2nd argument, b, to be of type float, but received 42

> lasterror;

"invalid input: %1 expects its %-2 argument, %3, to be of type %4, but received %5"

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

> A1:=proc(a::numeric, b::numeric) local a1, b1; assign(a1=a, b1=b); if not type(a, 'integer') then a1:=round(a) end if; if not type(b, 'float') then b1:=float(b) end if; a*b end proc: A1(64, 42), 17*A1(10/17, 59); ⇒ 2688, 590

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

При организации процедур роль типированных формальных аргументов не ограничивается только задачами проверки входной информации, но несет и ряд других важных нагрузок. В частности, использование uneval-типа для формального аргумента позволяет вне процедуры проводить его модификацию (т.е. обновлять на «месте» Maple-объект, определенный вне тела процедуры под этим идентификатором) как это иллюстрирует следующий фрагмент:

> A1(AVZ, 64), AVZ;

Error, (in A1) 1st argument must has type {list, set} but had received symbol-type > A1([1, 2, 3, 4, 5, 6], 64);

Error, (in A1) 1st argument must be symbol but had received list

Попытка определить такую операцию для стандартно типированного L-аргумента в Апроцедуре вызывает ошибку выполнения, тогда как, определив этот же L-аргумент как аргумент uneval-типа и использовав в дальнейшем обращение к нему через eval-функцию, получаем вполне корректную А1-процедуру, обеспечивающую обновление «на месте» списка/множества L путем удаления его элементов, определенных вторым a-аргументом, в качестве которого может выступать как отдельный элемент, так и их список/ множество. Проверка же на тип фактического L-аргумента производится уже программно в самой процедуре; при этом, проверяется не только на тип {list, set}, но и на получение идентификатора объекта, а не его значения (т.е. в качестве фактического L-аргумента должно выступать имя списка/множества). Данный прием может оказаться весьма полезным в практическом программировании, именно он используется рядом процедур нашей Библиотеки [41,103,108,109].

Начиная с Maple 10, кроме типирования формальных аргументов пакет допускает определение для позиционных аргументов значений по умолчанию. Кодируется это посредством оператора присвоения в формате <аргумент> := <значение>, например:

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

> P:=proc(f::symbol, x::symbol, {b:= evalf}, c::range(posint)) b(int(f(x), x=c)) end proc;

P := proc(f::symbol, x::symbol, c::range(posint), {b := evalf}) b(int(f(x), x = c)) end proc

> P(sin, y, 1..5, b=G), P(sin, y, 1..5, G), P(sin, y, 1..5, evalf), P(sin, y, 1..5, b);

G(cos(1) - cos(5)), 0.2566401204, 0.2566401204, true(cos(1) - cos(5))

Из него, в частности, следует, что использование в вызове процедуры такого аргумента в виде уравнения либо значения по умолчанию приводит к требуемым результатам, тогда как вызов только на левой части вместо фактического аргумента производит подстановку вместо фактического аргумента true-значения. В определенной мере данный механизм и его расширения в ряде случаев оказываются довольно полезными, однако вызывают несовместимость с более ранними релизами. Между тем, этот механизм в целом ряде случаев несложно реализуется программно и прежними средствами Maple-языка. Например, второй пример предпоследнего фрагмента может быть реализован способом, представленным последним примером фрагмента. Естественно, при большем количестве позиционных параметров программирование усложняется и представленный механизм более эффективен, одно ограничение – его действие ограничивается последними формальными аргументами.

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

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

Читателю рекомендуется разобраться с используемым практически полезным приемом.

Для организации процедуры наряду с предложениями, описывающими непосредственный алгоритм решаемой задачи (а в ряде случаев и для обеспечения самого алгоритма), язык Maple предоставляет ряд важных средств, обеспечивающих функции, управляющие выполнением процедуры. Прежде всего, к ним можно отнести переменные args и nargs, возвращающие соответственно последовательность переданных процедуре фактических аргументов и их количество. Оба эти средства имеют смысл только в рамках процедуры, а по конструкциям вида args{|[n]|[n..m]} можно получать {последовательность фактических аргументов|n-й аргумент| аргументы с n-го по m-й включительно} соответственно. Тогда как nargs-переменная возвращает количество полученных процедурой фактических аргументов. Назначение данных средств достаточно прозрачно и обусловливает целый ряд их важных приложений при разработке пользовательских процедур. В первую очередь, это относится к обработке получаемых процедурой фактических аргументов. В частности, nargs-переменная необходима с целью обеспечения определенности выполнения вычислений в случае передачи процедуре неопределенного числа аргументов. Следующий простой фрагмент иллюстрирует вышесказанное:

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

proc() <ТЕЛО> {Ψ(args[1], args[2], ..., args[n])|n = nargs} end proc {;|:} что оказывается весьма удобным механизмом для организации процедур, ориентированных, в первую очередь, на задачи символьных вычислений и обработки [9-14,39].

Дополнительно к переменным args и nargs можно отметить еще одну важную переменную procname, возвращающую имя процедуры, ее содержащей. В целом ряде случаев данная переменная оказывается весьма полезной, в частности, при возвращении вызова процедуры невычисленным. С этой целью используется конструкция простого формата 'procname(args)'. Многие пакетные процедуры возвращают результат именно в таком виде, если не могут решить задачу. Ряд процедур и нашей Библиотеки [103] поступают аналогичным образом. Между тем, переменная procname может использоваться и в других полезных приложениях. Следующий фрагмент иллюстрирует применение указанной переменной как для организации возврата вызова процедуры невычисленным, так и для вывода соответствующего сообщения:

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

Наконец, для проверки допустимости передаваемых процедуре необязательных аргументов служит процедура DefOpt(args), где args – передаваемые аргументы [41-43,103].

Исходные тексты процедур Библиотеки, прилагаемой к книгам [41,103] и к настоящей, предоставляют хороший иллюстративный материал по использованию аргументов, переменных процедуры args, nargs и procname для разработки различных приложений.

3.3. Локальные и глобальные переменные Mapleпроцедуры

Используемые в теле процедуры переменные по области определения делятся на две группы: глобальные (global) и локальные (local). Глобальные переменные определены в рамках всего текущего сеанса и их значения доступны как для использования, так и для модификации в любой момент и в любой Maple-конструкции, где их применение корректно. Для указания переменной глобальной ее идентификатор кодируется в global-секции определения процедуры, обеспечивая процедуре доступ к данной переменной. В этой связи во избежание возможной рассинхронизации вычислений и возникновения ошибочных ситуаций рекомендуется в качестве глобальных использовать в процедурах только те переменные, значения которых ими не модифицируются, а только считываются. Иначе не исключено возникновение отмеченных ситуаций, включая и непредсказуемые. Следующий пример иллюстрирует некорректность определения в процедуре глобальной хпеременной:

> x:= 64: proc(y) global x; x:= 0; y^(x+y) end proc(10); evalf(2006/x); ⇒ 10000000000 Error, numeric exception: division by zero

> x:= 64: proc(y) global x; x:= 0; y^(x+y) end proc: evalf(2006/x); ⇒ 31.34375000

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

Локальные переменные также можно типировать подобно аргументам, но действие этого типирования имеет смысл лишь при установке kernelopts(assertlevel=2), например:

> P:= proc(a, b) local c::integer; c:=a+b end proc: P(42.47,6); ⇒ 48.47

> kernelopts(assertlevel=2): P(42.47,6);

Error, (in P) assertion failed in assignment, expected integer, got 48.47

Если для переменных, используемых в определении процедуры, не определена область их действия (local, global), то Maple-язык классифицирует их следующим образом. Каждая переменная, получающая в теле процедуры определение по (:=)-оператору либо переменная цикла, определяемая функциями {seq, add, mul} полагается локальной (local), остальные полагаются глобальными (global) переменными. При этом, если переменные for-цикла не определены локальными явно, то выводится предупреждающее сообщение вида "Warning, `k` is implicitly declared local to procedure `P`”, где k и P – переменная цикла и имя процедуры соответственно. Тогда как уже для функций sum и product переменные цикла рассматриваются глобальными, не выводя каких-либо сообщений, что предполагает их явное определение в local-секции. Однако вне зависимости от наличия предупреждающих сообщений рекомендуется явно указывать локальные и глобальные переменные, что позволит не только избегать ошибок выполнения, но и более четко воспринимать исходный текст процедуры. Следующий фрагмент иллюстрирует вышесказанное:

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

(1) глобальными определять переменные, лишь используемые в режиме ”чтения”;

(2) локальные переменные определять явно в local-секции процедуры.

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

> restart; P:= proc(a, b) local x, y; x, y:= 42, 64; x, y end proc:

> x, y:= 42, 64: P(a, b), x, y; ⇒ 42, 64, 42, 64

> restart; P:= proc(a, b) local x, y; x, y:= a, b; x, y end proc:

> x, y:= 42, 64: P(a, b), x, y; ⇒ a, b, 42, 64

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

По assign-процедуре в теле процедур можно назначать выражения как локальным (заданным явно), так и глобальным (заданным явно либо неявно) переменным. Однако здесь имеется одно весьма существенное отличие. Как известно, пакет не допускает динамического генерирования имен в левой части (:=)-оператора присваивания, тогда как на основе assign-процедуры это возможно делать. Это действительно существенная возможность, весьма актуальная в целом ряде задач практического программирования [103]. Между тем, если мы по процедуре assign в теле процедуры будем присваивать выражения локальным переменным и сгенерированным одноименным с ними переменным, то во втором случае присвоения производятся именно глобальным переменным, не затрагивая локальных. Нижеследующий пример весьма наглядно иллюстрирует вышесказанное.

> restart; V42, G47:= 10, 17: proc() local V42, G47; assign(V42=64, G47=59); assign(cat(V, 42)=100, cat(G, 47)=200); [V42, G47] end proc(), [V42, G47]; ⇒ [64, 59], [100, 200]

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

Следует еще раз отметить, что для предложений присвоения в процедурах в целом ряде случаев использование assign-процедуры является единственно возможным подходом. Однако, при таком подходе в общем случае требуется, чтобы левая часть уравнения x=a в assign(x=a) была неопределенным именем, т.е. для нее должно выполняться соотношение type(x, 'symbol') = true. И здесь вполне допустимо использование конструкций следующего общего формата кодирования: assign(op([unassign('<Имя>'), <Имя>]) = <Выражение>)

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

> x:= 64: assign(op([unassign(x), x]) = 59); x; ⇒ 64

Error, (in unassign) cannot unassign '64' (argument must be assignable)

> P:= proc() end proc: M:= module() end module: T:= table([]): A:= array([]):

> map(whattype, map(eval, [P, M, T, A])); ⇒ [procedure, module, table, array]

> seq(assign(op([unassign(k), k])=59),k=[P,M,T,A]); [P,M,T,A], map(type, [P,M,T,A],'odd'); [59, 59, 59, 59], [true, true, true, true]

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

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

Процедура

(1) global (x = a) ⇒⇒⇒⇒⇒⇒⇒⇒ ⇒⇒ global (x = a)

(2) global (x = a) ⇒⇒⇒⇒⇒⇒⇒⇒ ⇒⇒ global (x = a)

(3) x ⇒⇒⇒⇒⇒⇒⇒⇒⇒ true ⇒⇒ ⇒⇒ x::{name|symbol} type(x, {'name|symbol'})

(4) (x = a) ⇒⇒⇒⇒⇒⇒ false ⇒⇒ ⇒⇒ x = a

В случае (1) явно либо неявно определенная х-переменная процедуры на всем протяжении текущего сеанса сохраняет свое значение до его переопределения вне или в самой процедуре. В случае (2) определенная локально в теле процедуры х-переменная в рамках процедуры может принимать значения, отличные от ее глобальных значений вне ее, т.е. в процедуре временно подавляется действие одноименной с ней глобальной х-переменной. Однако здесь имеют место и особые случаи (3, 4), не охватываемые стандартным механизмом. Для ряда функций, использующих ранжированные переменные (например, product, sum), возможны две ситуации, если такие переменные не декларировались в процедуре явно. Прежде всего, как отмечалось выше, не выводится предупреждающих сообщений о том, что они предполагаются локальными. Следовательно, они согласно трактовке языка Maple должны рассматриваться глобальными. Между тем, если на момент вызова процедуры, содержащей такие функции, ранжированная х-переменная была неопределенной (случай 3), то получая значения в процессе выполнения процедуры, после выхода из нее она вновь становится неопределенной, т.е. имеет место глобальное поведение переменной. Если на момент вызова процедуры х-переменная имела значение, то выполнение процедуры инициирует ошибочную ситуацию, а значение х-переменной остается неизменным (случай 4). Рассмотренные ситуации еще раз говорят в пользу явного определения входящих в процедуру переменных.

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

Данный фрагмент иллюстрирует использование локальной y-переменной в качестве ведущей переменной F(y)-полинома от одной переменной. Вне области действия процедуры глобальная y-переменная имеет конкретное числовое значение, т.е. их области не пересекаются.

Следующий простой фрагмент иллюстрирует взаимосвязь локальных и глобальных переменных, когда вторые определяются как явно в global-секции, так и неявно через assignпроцедуру. Второй же пример фрагмента иллюстрирует механизм действия uneval-типированного формального аргумента, когда (в отличие от стандарта) ему могут присваиваться выражения на уровне глобальных переменных. Применение подобного весьма полезного приема уже иллюстрировалось в предыдущем разделе.

> P:= proc() local a; global b; x:= 56; assign('m' = 67); a:= proc(x) m:= 47; assign('n' = 89); x end proc; x*a(3) end proc:

Warning, `x` is implicitly declared local to procedure `P`

Warning, `m` is implicitly declared local to procedure `a`

> n, m:= 100, 100: P(), n, m; ⇒ 168, 89, 67

> P1:= proc(m::uneval) local a, x; global b; a, x:= 59, 39; b:= 64; assign('m'=42) end proc: > m:= 64: P1(m), a, x, b, m; ⇒ a, x, 64, 42

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

в котором представлена простая рекуррентная цепочка выражений, вычисление которой реализует полностью рекуррентная подстановку и обеспечивает возврат конечного числового значения, т.е. производится полное вычисление для W-выражения, идентификатор которого полагается глобальным. С другой стороны, вызов функции eval(B, n) обеспечивает n-уровневое вычисление заданного ее первым фактическим В-аргументом выражения, что иллюстрирует второй пример фрагмента.

Для полного вычисления произвольного В-выражения используется вызов eval(B)-функции. Однако в первом примере фрагмента W-переменная является глобальной, что и определяет ее полное вычисление, если (как это иллюстрирует второй пример) не определено противного. Наконец, третий пример фрагмента иллюстрирует результат вычисления той же рекуррентной цепочки выражений, но уже составляющих тело процедуры и идентификаторы которых определены в ней локальными. Из примера следует, что если не определено противного, то процедура возвращает только первый уровень вычисления W-выражения и для его полного вычисления требуется использование функции eval, как это иллюстрирует последний пример фрагмента. Данное обстоятельство следует всегда иметь в виду, ибо оно не имеет аналогов в традиционных языках программирования и наряду с требованием особого внимания обеспечивает целый ряд весьма интересных возможностей программирования в различных приложениях.

Еще на одном моменте следует остановиться отдельно. По конструкциям op(2, eval(P)) и op(6, eval(P)) возвращается соответственно последовательность локальных и глобальных переменных процедуры P. И если в первом случае это действительно так, то во втором ситуация совершенно иная, а именно. Если в процедуре производятся присвоения переменным по assign-процедуре и эти переменные явно не определены глобальными, то второй вызов их не распознает, например:

> restart; P:= proc() local a, b, c; assign( x= 64, y = 59) end proc: P(): seq([op(k, eval(P))], k = [2, 6]), x, y; ⇒ [a, b, c], [], 64, 59

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

С этой целью нами была определена процедура Globals, обеспечивающая более точное тестирование глобальных переменных процедур. Вызов процедуры Globals(P) возвращает 2-элементную последовательность множеств глобальных переменных процедуры, определяемой фактическим аргументом Р. Первое множество возвращаемой последовательности содержит имена глобальных переменных, определяемых global-секцией процедуры Р, тогда как второе множество содержит имена глобальных переменных, которые определяются вызовами процедур пакетной assign и наших assign6, assign7, assign67 и Assign [41,103]. Процедура Globals функционирует в среде Maple 9 и выше. При этом, следует иметь в виду следующее важное обстоятельство, а именно.

Для простой процедуры (не содержащей внутри себя других процедур) вызов Globals(P) возвращает как определенные в global-секции Р переменные, так и переменные, значения которым присваивались процедурами assign, assign6, assign7, assign67 и Assign. Совсем иначе ситуация обстоит в случае вложенных процедур, когда вложенная процедура (подпроцедура) также содержит вызовы указанных процедур, но некоторые из вычисляемых ими переменных определены в local-секции подпроцедуры. В этом случае такие переменные, идентифицируясь Globals глобальными, на самом деле носят локальный характер. Сказанное хорошо иллюстрирует пример Proc-процедуры предыдущего фрагмента (переменные z и h). Данное обстоятельство следует учитывать при использовании процедуры Globals для вложенных процедур, содержащих assign-вызовы.

В целях повышения надежности при работе с глобальными переменными может быть использована процедура uglobal, чей вызов uglobal ('x', 'y', 'z',…) обеспечивает отмену значений глобальных переменных x, y, z, … на период выполнения процедуры, в которой данный вызов был сделан. После чего процедура может произвольно их использовать.

При этом, процедура uglobal в m-файле сохраняет значения всех переменных x, y, z, …, обеспечивая возможность их последующего восстановления вызовом uglobal(). Предыдущий фрагмент представляет исходный текст uglobal-процедуры и пример конкретного ее применения при работе с глобальной V-переменной в процедуре Р.

В Maple, начиная с 9-го релиза, для встроенной функции anames был определен аргумент 'user', по которому вызов anames('user') возвращает последовательность имен, значения для которых в текущем сеансе были определены пользователем. Данная возможность важна для приложений. В целях получения некоторого аналога данного средства для Maple релизов 8 и ниже нами была определена процедура pusers, исходный текст которой и пример применения представлены нижеследующим фрагментом.

Вызов процедуры pusers() возвращает множество имен процедур, определенных пользователем в текущем сеансе. При этом, в него не включаются те процедуры, определения которых находятся в Maple-библиотеках пользователя, логически сцепленных с главной библиотекой пакета. Данная процедура функционирует в среде Maple релизов 6 – 10.

Вызов представленной выше процедуры elib(e, L) возвращает true-значение, если объект е находится в Maple-библиотеке L, и false-значение в противном случае. Если указан и третий аргумент, то через него возвращается дата сохранения е-объекта в библиотеке.

3.4. Определяющие параметры и описания Mapleпроцедур

Прежде всего, представим секцию описания (description), завершающую описательную часть определения процедуры и при ее наличии располагающуюся между секциями {local, global, uses, options} и непосредственно телом процедуры. При отсутствии данных секций description-секция располагается непосредственно за заголовком процедуры и кодируется в следующем формате: description <Строчная конструкция> {:|;}

Определенная в данной секции строчная конструкция не влияет на выполнение процедуры и используется в качестве комментирующей компоненты, т.е. она содержит текстовую информацию, предназначенную, как правило, для документирования процедуры. При этом, в отличие от обычного комментария языка, которое игнорируется при чтении процедуры, описание ассоциируется с процедурой при ее выводе даже тогда, когда ее тело не выводится по причине использования рассматриваемой ниже опции Copyright. Более того, определяемый description-секцией комментарий может быть одного из типов {string, symbol}, как это иллюстрирует следующий простой фрагмент:

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

Рассмотрев секции local, global и description, несколько детальнее остановимся на секции {options|option}, которая должна кодироваться непосредственно за двумя первыми (или быть первой при их отсутствии) в описательной части определения процедуры. В качестве параметров (опций) данной секции допускаются следующие: builtin, arrow, Copyright, trace, operator, remember и call_external. При этом, перечень опций может зависеть от используемого релиза пакета.

Пакет располагает тремя типами процедур: встроенными непосредственно в ядро пакета, библиотечными и определяемыми самим пользователем. Параметр builtin определяет встроенную функцию пакета и при наличии он должен кодироваться первым в списке параметров option-секции. Данный параметр визуализируется при полном вычислении процедуры посредством eval-функции либо по print-функции, например:

> print(eval), eval(readlib); proc () option builtin; 169 end proc proc () options builtin, remember; 237 end proc

Каждая встроенная функция идентифицируется уникальным номером (зависящим от номера релиза пакета) и пользователь не имеет прямой возможности определять собственные встроенные функции. В приведенном примере первым выводится результат вызова print-функции, а вторым - eval-функции, из чего следует, что встроенные функции eval и readlib имеют соответственно номера 98 и 152 (Maple 8, тогда как уже для Maple 10 эти номера соответственно будут 117 и 274), а вторая процедура имеет дополнительно и опцию remember.

Для проверки процедур могут быть полезны и три наши процедуры ParProc, ParProc1 и Sproc [103], обеспечивающие возврат как основных параметров процедур, модулей и пакетов, так и их местоположение в библиотеках Maple, как это иллюстрирует следующий достаточно простой фрагмент:

С описанием данных процедур можно ознакомиться в [103], тогда как сами они включены в прилагаемую Библиотеку [109]. Там же можно получить и их исходные тексты.

Параметр Copyright определяет авторские права процедуры, ограничивая возможности вывода ее определения на печать. В качестве такого параметра пакет рассматривает любую конструкцию option-секции, начинающуюся с Copyright-слова. Все библиотечные Maple-процедуры определены с параметром Copyright, требуя для вывода на печать их определений установки опции verboseproc=n (n={2|3}) в interface-процедуре. Типичное содержимое option-секции библиотечных процедур имеет следующий вид:

option `Copyright (c) 1997 Waterloo Maple Inc. All rights reserved.`;

option {system,} `Copyright (c) 1992 by the University of Waterloo. All rights reserved.`;

в зависимости от релиза пакета; при этом, каждый релиз пакета совмещает процедуры и более ранних релизов. Текст любой пакетной процедуры (включая их remember-таблицы), кроме встроенных, можно получать по конструкции следующего простого вида: interface(verboseproc = 3): {print|eval}(<Id-процедуры>);

как это иллюстрирует следующий достаточно простой пример:

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

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

Совместное использование двух параметров operator и arrow информирует пакет о том, что процедура должна рассматриваться как функциональный (->)-оператор во всех ее вызовах, а также при выводе ее определения на печать, например:

Использование указанных параметров предполагает также упрощение тела процедуры. С другой стороны, как иллюстрируют примеры процедур G и S, далеко не каждая процедура допускает представление в нотации функционального (->)-оператора. Данную возможность допускают, как правило, простые процедуры, реализованные однострочным экстракодом, что иллюстрирует простая G-процедура первого примера фрагмента. Прежде, чем переходить к рассмотрению важного remember-параметра, представим общие средства доступа к процедурным объектам Maple-языка. Для идентификации процедурного типа Proc-объекта служат два ранее рассмотренных тестирующих средства: type(Proc, 'procedure') и whattype(eval(Proc))

возвращающие соответственно значения true и procedure, если Proc-объект является процедурой Maple, определенной любым из трех рассмотренных выше способов, и, кроме того, вычисленной. Следующий простой фрагмент иллюстрирует вышесказанное:

> O1:= proc() end proc: [type(O1, procedure),whattype(eval(O1))]; ⇒ [true, procedure] > O2:= () -> sum(args[k], k=1..nargs): [type(O2, 'procedure'), whattype(eval(O2))];

[true, procedure]

> define(O3, O3(x::anything, y) = x*y): [type(O3, 'procedure'), whattype(eval(O3))];

[true, procedure]

> Type_Proc:= proc(Id) `if`((type(Id, 'symbol') = true) and (whattype(eval(Id)) =

`procedure`), true, false) end proc: map(Type_Proc, [O1, O2, O3]); ⇒ [true, true, true]

В частности, последний пример фрагмента представляет простую тестирующую процедуру Type_Proc, возвращающую true-значение лишь тогда, когда объект, приписанный Id-идентификатору, является Maple-процедурой. При этом, еще раз следует обратить внимание на то обстоятельство, что корректное применение тестирующей процедуры whattype предполагает полное вычисление процедурного объекта, что обеспечивается использованием eval-функции, рассмотренной выше.

Так как программная структура процедуры вычисляется по специальным табличным правилам, то для полного доступа к ее элементам следует использовать eval-функцию, производящую полное вычисление процедуры, подобно тому, как она это делает для других структур, например массивов. По eval(Proc)-вызову возвращается определение процедуры, приписанное Proc-переменной, в качестве которой может выступать любой допустимый идентификатор. В связи со сказанным по whattype(Proc)-вызову возвращается symbol-значение, а по вызову whattype(eval(Proc)) – procedure-значение. Поэтому по op(n, eval(Proc))-вызову возвращается значение восьми компонент определения процедуры, приписаного Proc-переменной. В табл. 7 представлены n-значения для указанной конструкции и их смысловая нагрузка:

Таблица 7

В случае отсутствия в определении процедуры какой-либо из рассмотренных секций на соответствующем ей n-значении конструкция op(n, eval(Proc)) возвращает NULL-значение. По nops(eval(Proc))-вызову всегда возвращается значение 8 (начиная с Maple 7) – максимально возможное число составляющих компонент определения Proc-процедуры. Вместе с тем, в число данных компонент не входит само тело процедуры и для возможности доступа к нему используется прием, рассматриваемый несколько ниже. Следующий достаточно прозрачный фрагмент иллюстрирует вышесказанное:

В приведенном фрагменте определяется простая IAN-процедура, содержащая все допустимые компоненты определения Maple-процедуры, и производится ее вычисление, выводящее на экран только частичный текст определения процедуры, ибо при ее определении был задействован Copyright-параметр option-секции. Однако, возвращаемое в результате вычисления определение является полным и его последующий вызов возвращает корректные результаты, как это иллюстрирует последний пример фрагмента с непоименованной процедурой. После вычисления определения производится двухкратный вызов процедуры; последующее использование op(k, eval(IAN))-конструкции в (for_do)предложении выводит содержимое всех восьми компонент IAN-процедуры.

Как следует из вышесказанного, тело процедуры рассмотренными средствами не идентифицируется в качестве ее компоненты и доступ к нему возможен иными средствами, рассматриваемыми несколько ниже. Здесь же уместно отметить лишь dismantle(P)-процедуру, обеспечивающую вывод структуры данных, определяемой P-выражением. Процедура выводит структуру P-выражения (которое для случая процедуры должно быть полностью вычисленным) в разрезе составляющих его подвыражений (компонент), их длины и относительные адреса в {десятичном|16-ричном|8-ричном} представлении. Следующий фрагмент иллюстрирует вывод структуры данных, отвечающей IAN-процедуре предыдущего примера:

> dismantle(eval(IAN));

PROC(9) #[`Copyright Tallinn Research Group * 29.03.99`, remember]

EXPSEQ(4)

DCOLON(3)

NAME(4): x

NAME(5): float #[protected]

DCOLON(3)

NAME(4): y

NAME(5): integer #[protected]

DCOLON(3)

NAME(4): z

NAME(5): numeric #[protected]

EXPSEQ(3)

NAME(4): k

NAME(4): h

EXPSEQ(3)

NAME(14): `Copyright Tallinn Research Group * 29.03.99`

NAME(6): remember

HASHTAB(129)

HASH(7)

EXPSEQ(4)

FLOAT(3): 19.95

INTPOS(2): 1995

INTNEG(2): -2

INTPOS(2): 59

FLOAT(3): 19.99

INTPOS(2): 1999

INTNEG(2): -2

FLOAT(3): 96.82051282

INTPOS(4): 9682051282

INTNEG(2): -8

HASH(7)

EXPSEQ(4)

FLOAT(3): .1

INTPOS(2): 1

INTNEG(2): -1

INTPOS(2): 17

FLOAT(3): 1.1

INTPOS(2): 11

INTNEG(2): -1

FLOAT(3): 27.89743590

INTPOS(4): 2789743590

INTNEG(2): -8

PROD(7)

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

Набор из процедуры dismantle и 4-х функций assemble, addressof, disassemble и pointto известен как "хакерский" пакет в Maple. Последние четыре функции обеспечивают доступ к внутренним представлениям объектов Maple и к адресам, указывающим на них. Между тем, пользователь должен быть знаком с внутренним представлением объектов пакета перед использованием данного набора средств. Для этого рекомендуем обратиться, например, к руководствам [83,84]. Некоторые средства подобного типа представлены и в [41,42,103].

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

А именно, по remember-параметру с Proc-процедурой ассоциируется специальная таблица remember, которую можно получать по уже рассмотренной op(4, eval(Proc))-конструкции. Данная таблица аналогична обычной table-структуре, допуская те же средства обработки, что и последняя. Она содержит все вызовы процедуры, включая рекурсивные, в разрезе передаваемых значений фактических аргументов и возвращаемых на них процедурой значений (результатов вызовов). Данная таблица для произвольной Proc-процедуры имеет следующий простой вид, из которого довольно просто при необходимости извлекать ранее полученные значения вызовов процедуры:

> op(4, eval(Proc));

table([

(<Фактические аргументы_1>) = <Возвращаемое значение_1>

============================================== (<Фактические аргументы_h>) = <Возвращаемое значение_h>])

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

Между тем, использование remember-механизма может наряду с повышением эффективности выполнения процедуры существенно использовать ресурсы оперативной памяти ЭВМ, требуемые для размещения remember-таблицы. В этом случае требуется нахождение оптимального консенсуса, обеспечиваемого, в частности, возможностью как полного обнуления таблицы, так и отдельных ее входов. В частности, совместное использование с remember-параметром system-параметра обеспечивает автоматическую очистку (без ее удаления) remember-таблицы в процессе выполнения ядром периодических операций по очистке от “муссора” занимаемой текущим сеансом памяти ПК. Именно поэтому не следует использовать system-параметр для тех процедур, текущий результат выполнения которых зависит от истории вычислений, как это имеет место для рекурсивных процедур. Другие средства Maple-языка позволяют производить модификацию remember-таблицы более дифференцированно.

Для обнуления remember-таблицы Proc-процедуры применяется процедура forget(Proc). Вызов forget(Proc{, А}{, 0}) позволяет удалять из remember-таблицы входы для определяемой первым фактическим аргументом Proc-процедуры. При этом, допускается передавать Proc-процедуре фактические А-аргументы и использовать необязательные две Оопции (reinitialize, subfunction), управляющие непосредственным выполнением forgetпроцедуры. Детальнее с ними можно ознакомиться по справке пакета. Посредством передачи фактических А-аргументов обеспечивается возможность удаления из rememberтаблицы указанной Proc-процедуры ее конкретных Proc(A)-вызовов. Тогда как в случае отсутствия фактических А-аргументов remember-таблица полностью обнуляется, однако оставаясь ассоциированной с данной процедурой. Наконец, посредством выполнения подстановки subsop(4=NULL, eval(Proc)) производится удаление таблицы remember для Proc-процедуры. Однако, forget-процедуру следует использовать с определенной осмотрительностью.

Прежде всего, forget-процедуру не рекомендуется использовать для расширенного управления remember-таблицей процедур, т.к. она, в частности, не работает с целым рядом модульных процедур пакета, а также со многими процедурами, определенными в модулях Share. Ряд достаточно простых примеров нижеприведенного фрагмента иллюстрирует вышесказанное. Для модификации процедурной таблицы можно использовать и нашу процедуру Remember_T от неопределенного числа формальных аргументов, по которой производится редактирование входов и выходов таблицы. Следующий простой фрагмент иллюстрирует текст процедуры [12,103] и примеры ее применения:

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

[x1, x2, …, xn] = <Значение> либо [x1, x2, …, xn]

где первый формат определяет необходимость замены выхода на (x1, x2, …, xn)-входе таблицы remember на заданное значение или помещение в таблицу нового входа, если указанный отсутствует, либо удаления заданного входа из таблицы. Затем определяется P3-процедура с опцией remember, согласно которой для процедуры создается с remember-таблица. После трех вызовов процедуры содержимое этой таблицы выводится. Последующий вызов Remember_T-процедуры иллюстрирует результат модификации remember-таблицы процедуры P3 в разрезе перечисленных трех операций. Организация Remember_T не рассматривается и оставляется читателю в качестве полезного упражнения.

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

Между тем, наиболее важной особенностью remember-параметра является возможность на основе remember-таблицы определять эффективные во временном отношении рекурсивные процедуры. Обеспечивая возможность определения рекурсивных процедур, механизм ядра, вместе с тем, определяет эффективность их выполнения в зависимости от использования таблицы remember. В конце предыдущего фрагмента приведены две простые функционально эквивалентные рекурсивные процедуры Fib и Fib1, вычисляющие числа Фибоначчи; при этом, описательная часть Fib1-процедуры включает rememberпараметр. Временные результаты вызова обоих процедур говорят сами за себя. По экспертным оценкам ассоциирование с процедурами remember-таблиц позволяет на целом ряде задач получать экспоненциальный временной выигрыш за счет определенных ресурсов памяти в виде требуемого места под remember-таблицу. В частности, для нашего примера remember-таблица Fib1-процедуры содержит 32 входа, что не соизмеримо с полученным временным выигрышем. Однако возможно и наоборот, например, при использовании процедур в циклических конструкциях (пример Proc_30-процедуры фрагмента). Для модификации remember-таблицы произвольной Proc-процедуры, определение которой содержало remember-параметр, наряду с приведенной выше Remember_T-процедурой можно использовать конструкции следующего простого вида:

Proc(<Фактические аргументы (ФА)>) := <Требуемый результат> {:|;}

T := op(4, eval(Proc)): T[(<ФА>)] := evaln(T[(<ФА>)]) {:|;}

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

> P:= proc() local k; options remember; sum(args[k], k= 1 .. nargs) end proc: # (1)

> [P(10, 17, 39, 44, 59, 64), P(96, 89, 67, 62, 47, 42), P(11, 6, 98, 445, 2006)]: op(4, eval(P)); table([(11, 6, 98, 445, 2006) = 2566, (96, 89, 67, 62, 47, 42) = 403, (10, 17, 39, 44, 59, 64) = 233])

> P(42, 47, 67, 89, 96):= 2006: P(56, 51, 31, 2, 9):= 2500: op(4, eval(P)); # (2) table([(42, 47, 67, 89, 96) = 2006, (11, 6, 98, 445, 2006) = 2566, (96, 89, 67, 62, 47, 42) = 403,

(56, 51, 31, 2, 9) = 2500, (10, 17, 39, 44, 59, 64) = 233])

> T:= op(4, eval(P)): T[(42, 47, 67, 89, 96)]:= evaln(T[(42, 47, 67, 89, 96)]): op(4, eval(P)); table([(11, 6, 98, 445, 2006) = 2566, (96, 89, 67, 62, 47, 42) = 403, (56, 51, 31, 2, 9) = 2500,

(10, 17, 39, 44, 59, 64) = 233])

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

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

> GS:=proc(x) evalf(1/x,3) end proc: GS(0):=infinity: map(GS, [10,0,17]); ⇒ [0.100, ∞, 0.0588] > op(4, eval(GS)); ⇒ table([0 = ∞])

Данный фрагмент иллюстрирует еще один важный момент, связанный с процедурами, а именно. С каждой процедурой независимо от наличия в ее определении remember-параметра ассоциируется remember-таблица, сохраняющая историю присвоений по конструкциям Proc(ФА):= <Значение> и assign('Proc(ФА)', <Значение>), где Proc – процедура, определенная любым допустимым способом, и ФА - ее фактические аргументы, на которых она принимает указанное значение. Таким образом, remember-таблица для Procпроцедуры может создаваться двумя способами, а именно:

(1) Proc := proc(...) option remember; ... end proc {:|;}

(2) Proc := proc(...) ... end proc: Proc(ФА) := <Значение> {:|;}

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

> G:= proc(x) x end proc: [assign('G(42)', 647), assign('G(47)', 59), assign('G(67)', 39)]:

> G1:= x -> x: [assign('G1(42)', 64), assign('G1(47)', 59), assign('G1(67)', 39)]:

> define(G2, G2(x::numeric) = x): [assign('G2(42)', 64), assign('G2(47)', 59), assign('G2(67)',

39)]: op(4, eval(G)), op(4, eval(G1)), op(4, eval(G2)); table([67 = 39, 42=64, 47 = 59]), table([67 = 39, 42=64, 47 = 59]), table([67 = 39, 42=64, 47 = 59]) > P:= proc(x) option remember; x^10 end proc: for k to 3 do P(k) end do:

> P1:= proc(x) x^10 end proc: P1(42):= 64: P1(47):= 59: for k to 5 do P1(k) end do: op(4, eval(P)), op(4, eval(P1)); ⇒ table([1 = 1, 2 = 1024, 3 = 59049]), table([42 = 64, 47 = 59])

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

3.5. Механизмы возврата Maple-процедурой результата ее вызова

В результате вызова стандартным является возврат результата выполнения процедуры через значение последнего предложения ее тела. Однако, Maple-язык поддерживает еще три основных механизма возврата результата вызова процедуры: через фактический аргумент, функцию RETURN (return-предложение) и ERRОR-функцию (error-предложение). В случае возникновения ошибочной ситуации в период выполнения процедуры производится аварийный выход из нее с выводом соответствующего сообщения. В отсутствие ошибочных ситуаций предварительно вычисленная процедура с Proc-именем (идентификатор, которому присвоено определение процедуры) вызывается подобно функции по конструкции следующего формата кодирования:

Proc(<Фактические аргументы>)

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

RETURN(<Последовательность выражений>) return <Последовательность выражений> {:|;}

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

Первые три примера фрагмента представляют простые процедуры AG, SV и MV, назначение первой из которых легко усматривается из ее определения, а две другие возвращают соответственно результат тестирования и список номеров позиций вхождения хэлемента в заданный L-список. Все три процедуры возвращают результат стандарным способом через последнее предложение тела процедуры. Остальные примеры фрагмента иллюстрируют возврат результата процедуры RETURN-функцией либо return-предложением.

Процедура ММ возвращает список с номером позиции первого вхождения х-элемента в L-список и сам элемент, в противном случае возвращается false-значение. Процедура для возврата результата вызова использует как стандартный метод, так и RETURN-функцию. При этом, рекомендуется обратить внимание на реализацию процедуры однострочным экстракодом. Процедура ТР возвращает результат анализа получаемых при ее вызове фактических аргументов в разрезе числовых и нечисловых с идентификацией количества аргументов обоих типов. Процедура VS возвращает таблицу, первый столбец которой содержит передаваемые процедуре вычисленные фактические аргументы, тогда как второй - их типы. Одним из достоинств использования функции RETURN является возможность эффективного возврата значений локальных переменных из целого ряда важных вычислительных конструкций, а также обеспечение гибкой возможности избирательности возврата результатов вызова пользовательских процедур. Тогда как предложение return имеет существенно меньшие выразительные возможности по представлению вычислительных алгоритмов в среде Maple-языка.

Следует отметить, что, начиная с Maple 6, разработчики объявили о том, что RETURNфункция является устаревшим средством (obsolete) и сохранена для обеспечения обратной совместимости процедур, разработанных в предыдущих релизах пакета. При этом, настоятельно рекомендуя использование именно return-предложения. Наш опыт работы с Maple говорит совершенно об обратном. Использование RETURN-функции во многих случаях более предпочтительно, позволяя создавать эффективные выходы из вычислительных конструкций, прежде всего, в однострочных экстракодах. Ниже на этом моменте акцентируем несколько больше внимания.

В общем случае функция RETURN(V1,V2 ,..., Vn), где в качестве фактических аргументов могут выступать произвольные Maple-выражения, предварительно вычисляемые, может не только возвращать конкретные результаты вычисления Vk-выражений, связанных со спецификой тела процедуры, но и возвращать в определенных условиях вызов процедуры невычисленным. Для этих целей, как правило, используется конструкция вида RETURN('Proc(args)'), где Proc – имя (идентификатор) процедуры. Библиотечные процедуры Maple в случае некорректного либо прерванного вызова возвращают FAILзначение, если нецелесообразно возвращать вызов процедуры невычисленным. Следующий простой фрагмент иллюстрирует вышесказанное:

В данном фрагменте LO-процедура в случае обнаружения среди переданных ей фактических аргументов выражения типа, отличного от float, сразу же осуществляет выход по return-предложению с возвращением своего вызова невычисленным. Тогда как второй пример иллюстрирует возврат невычисленных вызовов базовых функций Maple-языка.

В целом ряде случаев возвращать результат вызова процедуры представляется весьма удобным через ее формальный h-аргумент, который кодируется в заголовке процедуры в последовательности ее формальных аргументов в виде h{::evaln}. Соответствующие же им фактические аргументы кодируются в виде {'H'|H}, т.е. процедуре сообщается, что ей передается не значение соответствующего ему фактического аргумента, а его идентификатор. В этом случае в теле процедуры производится присвоение данному фактическому аргументу-идентификатору требуемого значения, которое доступно сразу же после вызова процедуры. Следующий простой фрагмент иллюстрирует вышесказаное:

Первый пример фрагмента представляет G-процедуру, допускающую при своем вызове четыре фактических аргумента, из которых три последних имеют evaln-тип и через которые передаются списки фактических аргументов, имеющих типы float, integer и fraction соответственно. Тогда как в качестве основного возврата процедуры является результат вычисления корня квадратного из суммы фактических аргументов, переданных процедуре при ее вызове. Пример вызова процедуры G иллюстрирует сказанное. Второй пример фрагмента представляет G1-процедуру, являющуюся модификацией предыдущей процедуры и допускающей при своем вызове более четырех фактических аргумента, из которых четыре первых аналогичны случаю процедуры G, тогда как через пятый необязательный аргумент передается множество типов фактических аргументов процедуры, отличных от типов {float, integer, fraction}. Тогда как основной возврат процедуры аналогичен случаю G-процедуры. Пример вызова процедуры иллюстрирует сказанное. В обеих процедурах рекомендуется обратить внимание на использование процедуры/орператора &ma [103], обеспечивающего присвоение одного и того же выражения последовательности переменных, и assign-процедуры для присвоения значений фактическим аргументам, через которые обеспечиваются вторичные возвраты процедуры.

Между тем, возвращать вторичные результаты вычислений процедур возможно и через ее фактические аргументы, не определяемые evaln-типом и имеющие symbol-тип; в этом случае их рекомендуется кодировать в невычисленном формате, т.е. в прямых верхних кавычках. Следующий фрагмент на процедуре Kris иллюстрирует описанный подход.

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

Maple вычисляет формальные аргументы один раз, поэтому их не следует использовать в теле процедуры подобно локальным переменным. Формальному аргументу, через который будет возвращаться результат вызова процедуры, в ее теле должно быть выполнено только одно присвоение, определяющее возвращаемый результат, отличный от основного. При этом, в ряде случаев процедура может вполне обходиться без основного возврата, ограничиваясь только вторичными, а то даже и вовсе без них. В обоих случаях вызов такой процедуры возвращает NULL-значение, т.е. ничего. Механизм возврата результатов вызова Maple-процедуры через ее фактические аргументы дает возможность наряду со стандартным или на основе RETURN-функции подходами организовывать дополнительные (вторичные) выходы, определяемые наличием или отсутствием при вызове процедуры соответствующих аргументов. Подобная организация возврата результатов вызова достаточно широко практикуется в библиотечных процедурах как собственно самого пакета Maple, так и наших [41,103,109].

Механизм возврата результатов вызова Maple-процедуры через ее фактические аргументы позволяет наряду со стандартным либо на основе RETURN-функции (return-предложения) подходами организовывать и дополнительные выходы, определяемые как наличием либо отсутствием при вызове процедуры соответствующих аргументов, так и выполнением оп-еделенных условий. Такая организация возврата результата вызова широко практикуется в пакетных процедурах. Наряду с представленными выше механизмами возврата результатов вызова процедуры можно предложить еще один механизм, полезный в целом ряде приложений и используемый рядом процедур нашей Библиотеки [103,109]. Суть его состоит в следующем.

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

Proc:= proc({Id1} {, Id2} … {, Idp}) local t; if member('Id1', [args], 't') then assign(args[t] = expr1) end if; if member('Id2', [args], 't') then assign(args[t] = expr2) end if;

……………………………………………………………...….………

`if`(member('Idp', [args], 't'), assign(args[t] = exprp), NULL) end proc:

где exprk – Maple-выражение (k=1..p). При этом, следует иметь в виду, что здесь требуется использование assign-процедуры, а не (:=)-оператора присваивания, т.е. assign(args[t] = expr), а не args[t] := expr. В противном случае Maple выводит предупреждение о недопустимости использования переменной args в качестве локальной переменной с последующим инициированием ошибочной ситуации с диагностикой «Error, args cannot be declared as a local». Это еще один пример принципиальных различий оператора присваивания (:=) и assign-процедуры.

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

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

Как уже отмечалось выше, определение процедуры допускает следующий формат:

Proc := proc(args)::type; … end proc

который допустим только в релизах 7 и выше пакета, вызывая в Maple 6 ошибку.

Кодирование за заголовком процедуры типа не является в полном смысле слова типированием возвращаемого процедурой результата, а скорее утверждением (assertion). При установке kernelopts(assertlevel=2) производится проверка типа возвращаемого результата вызова процедуры. Если тип не соответствует утверждению, то возникает ошибочная ситуация с диагностикой "assertion failed: %1 expects its return value to be of type %2, but computed %3". При остальных установках assertlevel–опции утверждение игнорируется. Особого смысла в данном формате мы не видим и вот почему. Если необходимо типировать результат возврата, то намного удобнее и эффективнее это делать в самой процедуре на основе как реализуемого ею алгоритма, так и получаемых типов фактических аргументов. При этом, сохраняется непрерывность вычислений и производится обработка ошибочных и особых ситуаций, связанных с типом возвращаемого результата. Более того, при качественной разработке процедуры в ней уже должна быть предусмотрена (при необходимости) проверка типов получаемых ею фактических аргументов. Так что и здесь имеется «фильтр» на допустимось фактических аргументов. К тому же, если такого формата процедура находится в библиотеке и используется для программирования, то при возникновении ошибки указанного выше типа пользователю будет весьма сложно обнаружить причину такой ошибки, привязанной лишь к результату вызова процедуры, которая может иметь и несколько разнотипных точек возврата В одном лишь, пожалуй, можно согласиться, что такого рода «типизация» в некотором роде подобна типизации формальных аргументов, но относится к результатам ее вызова, и может в ряде случаев представить интерес, например, в случае множественности точек возврата процедуры, упрощая обработку типов результатов вызова. Следующий простой фрагмент иллюстрирует результат использования указанного формата кодирования процедуры:

Фрагмент содержит подпроцедуру conv, результат вызова которой обеспечивает конвертирование возвращаемого процедурой Р1 выражения в тип, заданный после заголовка процедуры. Возможно, в некоторых случаях такой прием может оказаться полезным. В частности, кодировать после заголовка процедуры Р можно любое корректное Maple-выражение, доступное внутри процедуры по вызову op(8, eval(Р)), что предоставляет целый ряд дополнительных возможностей при программировании приложений, как это иллюстрируют две последние процедуры Р и Р2 фрагмента.

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

3.6. Средства обработки ошибочных и особых ситуаций в Maple-языке пакета

В процессе вычисления Maple-конструкций возможно появление особых и аварийных ситуаций, которые в большинстве случаев требуют специальной обработки во избежание серьезного нарушения всего вычислительного процесса. Идентифицируемые пакетом ситуации такого рода возвращаются в предопределенную lasterror-переменную, значение которой определяет последнюю обнаруженную в текущем сеансе ошибку и доступно текущему сеансу для необходимой обработки возникшей ситуации. Значение lasterror-переменной определяется только в момент возникновения ошибочной ситуации, а сразу же после загрузки пакета она является неопределенной. К lasterror-переменной непосредственно примыкает и tracelast-функция, обеспечивающая вызов последней ошибочной ситуации из стэка ошибок пакета. При этом, между ними имеется принципиальное различие, а именно: через lasterror-переменную возвращается ошибочная диагностика, обрабатываемая функциональными средствами языка, тогда как tracelast-функция инициирует вызов последней ошибочной ситуации, если она не была удалена из стэка ошибок. Значение lasterror-переменной имеет string-тип. Следующий простой пример иллюстрирует применение обоих указанных средств Maple-языка, предназначенных для обработки ошибочных ситуаций:

> read("D:/Academy/UserLib6789/Common/HelpBase/SveGal.mws");

Error, unable to read `D:/Academy/UserLib6789/Common/HelpBase/SveGal.mws`

> lasterror; ⇒ "unable to read `%1`"

> tracelast;

Error, unable to read `D:/Academy/UserLib6789/Common/HelpBase/SveGal.mws`

Для обработки ошибочных ситуаций в ранних релизах совместно с lasterror-переменной использовалась функция traperror(V1,V2, ..., Vn), по которой возвращается сообщение, соответствующее первой встреченной ошибочной ситуации в выражениях Vk (k = 1..n). При этом, каждый вызов функции traperror отменяет определение предопределенной переменной lasterror. Это же производится и по traperror()-вызову. Если же при вызове функции traperror не обнаружено особых ситуаций, то она возвращает упрощенные/вычисленные выражения, входящие в состав ее фактического аргумента. В случае указания в качестве фактического аргумента последовательности выражений только первому, вызвавшему ошибочную ситуацию, приписывается соответствующее диагностическое сообщение. Данное сообщение может использоваться совместно с lasterror-информацией для организации обработки особых и ошибочных ситуаций, возникающих в процессе вычислений в документе или Maple-процедуре. Следующий простой пример иллюстрирует вышесказанное:

> VS:=0: AG:=15.04: if (traperror(AG/VS)=lasterror) then T:=AG/10.17 end if: [T, lasterror];

[1.478859390, "numeric exception: division by zero"]

В данном примере на основе вызова traperror(AG/VS) и lasterror обрабатывается особая ситуация “деление на нуль”, в результате чего производится устранение данной ситуации путем перехода к вычислению другого выражения. При этом, следует обратить внимание на то обстоятельство, что при возникновении ошибочной ситуации в вычисляемом по traperror-функции выражении сообщение о ней поглощается функцией, не отражаясь в документе. Большинство серьезных особых и аварийных ситуаций идентифицируется предопределенной lasterror-переменной, поэтому совместное использование указанных средств может оказаться достаточно эффективным. При этом, следует иметь в виду, что ряд возникающих особых ситуаций не обрабатывается функцией traperror. В общем же случае, следующие ошибочные и особые ситуации не обрабатываются traperror:

* interrupted (прерванное вычисление)

* assertion failed (генерируется при активном ASSERT-механизме)

* out of memory (недостаток па-мяти),

* stack overflow (переполнение стэка) * object too large (объект слишком велик).

Это объясняется невозможностью восстановления на момент возникновения указанных ситуаций. При этом, следует иметь в виду, что вызов traperror(V) не связывает с V-выражением особой ситуации типа “деление на нуль”, если в качестве V-аргумента выступает конструкция следующего вида {V/0|V/(a-a)|V/(a*0)}, т.е. если знаменатель дроби тождественно равен нулю, а не принимает нулевого значения в результате вычисления (присвоения) или упрощения выражения. Следующий фрагмент иллюстрирует сказанное:

Последний пример фрагмента иллюстрирует тот факт, что порядок следования переменной lasterror и вызова traperror-функции в логической паре в общем случае существенен и первой следует кодировать traperror-функцию. Между тем, повторное выполнение ifпредложения последнего примера фрагмента возвращает корректные результаты, т. к. значение lasterror-переменной сохраняет последнюю ошибочную ситуацию. Ниже мы еще раз вернемся к рассмотренным средствам обработки ошибочных и особых ситуаций, однако следует отметить, что traperror-функция в значительной мере является устаревшим (obsolete) средством и его заменяет появившееся для данных целей в Maple 6 более функционально широкое try-предложение, рассматриваемое ниже.

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

По time-функции, имеющей формат кодирования следующего простого вида: time({ |<Выражение>})

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

Фрагмент включает пример простой Time-процедуры, возвращающей общее время от начала текущего сеанса работы с пакетом в минутах и часах. Функция time используется для организации управления вычислениями в контексте их временных характеристик и может служить в качестве средства управления непредсказуемыми по времени вычислениями (циклы, итерации и др.).

Вторым средством, обеспечивающим временной контроль вычислений, служит встроенная функция timelimit(t, V). Если время в сек., затребованное процессором для вычисления V-выражения, не превысило значения, определенного первым фактическим t-аргументом, то возвращается результат вычисления V-выражения. В противном случае генерируется ошибочная ситуация с диагностикой "Error, (in V) time expired", обрабатываемая рассмотренной выше traperror-функцией или try-предложением, рассматриваемым ниже. Однако функция timelimit не используется с функциями машинной арифметики, т.к. не обрабатывает ситуацию исчерпания отведенного временного интервала для вычислений, например:

> S:= proc(n) local k; for k to n do sin(10.3*n) end do end proc: S(10^5), evalhf(S(10^5)), timelimit(3, evalhf(S(10^7)));

-0.5431520991, -0.543152099236042907, 0.764330635010303183

> timelimit(3, S(10^7));

Error, (in sin) time expired

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

В качестве примера применения timelimit-функции предыдущий фрагмент представляет простую Timetest(t, x, V, p)-процедуру, возвращающую true-значение только в том случае, когда вычисление V(x)-выражения укладывается в отведенный ему интервал в tсекунд, в противном случае ею возвращается false-значение. При этом, через аргумент p процедуры возвращается список, первый элемент которого определяет время вычисления искомого выражения, а второй - результат вычисления либо undefined-значение соответственно. В данном фрагменте Timetest-процедура применяется для временного тестирования вызова простой G-процедуры. При этом, следует иметь в виду, что в общем случае совместное использование функций time и timelimit в одной процедуре может приводить к некорректным результатам [12]. Вместе с тем, при получении определенного навыка использования функциональных средств языка существующих средств обработки особых и аварийных ситуаций оказывается вполне достаточным для создания в среде Maple довольно эффективных пользовательских систем обработки ситуаций такого рода. Более того, на основе знания специфики реализуемого в среде языка алгоритма решаемой задачи функциональные средства Maple-языка дают возможность проводить предварительный программный анализ на предмет предупреждения целого ряда возможных особых и аварийных ситуаций. Рассмотрим теперь вопросы обработки особых и аварийных ситуаций в контексте программирования процедур.

По функции ERROR, имеющей формат кодирования следующего вида:

ERROR({V1, V2, …, Vn})

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

Error, (in {Proc|unknown}) {<V1>, <V2>, ... ,<Vn>}

где Proc - имя процедуры, вызвавшей ERROR-ситуацию, и <Vk> - результат вычисления Vk-выражения (k = 1 .. n); unknown-идентификатор выводится для непоименованной процедуры. Тогда как по предложению error, имеющему формат кодирования вида: error {Msg {, p1, p2, …, pn}} {:|;}

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

Error, (in {Proc|unknown}) { Msg({p1, p2, …, pn})}

где Proc – имя процедуры, вызвавшей error-ситуацию, и <Msg({p1,p2,…,pn})> - результат подстановки pk-параметров в Msg-сообщение; unknown-идентификатор выводится для непоименованной процедуры. Msg - строка текста, определяющая суть ошибочной ситуации. Она может содержать пронумерованные параметры вида «%n», где n – целое число от 0 до 9. Тогда как pk – один или более параметров (Maple-выражений), которые подставляются вместо соответствующих по номеру вхождений '%n', когда возникает ошибочная ситуация. Например:

> error “invalid arguments <%1> and <%2>”, 3, 7; Error, invalid arguments <3> and <7> > 64/0;

Error, numeric exception: division by zero

> error;

Error, numeric exception: division by zero

> restart; error;

Error, unspecified error

При этом, если Msg отсутствует, то выполнение error-предложения в качестве диагностики выводит диагностику последней ошибочной ситуации текущего сеанса, если же и такой нет, то возвращается сообщение о неспецифицированной ошибке. Если параметр имеет вид '%n', то в возвращаемом сообщении он появляется как n-й параметр in lprintнотации, тогда как вид '%-n' обеспечивает его появление в сообщении в обычной нотации, например:

> error “%1 and %2 arguments are invalid”, 3, 7; Error, 3rd and 7th arguments are invalid

> error “%-1 and %-2 arguments are invalid”, 3, 7; Error, 3rd and 7th arguments are invalid

> ERROR(“%-1 and %-2 arguments are invalid”, 3, 7);

Error, 3rd and 7th arguments are invalid

Сказанное в полной мере относится и к оформлению ERROR-функции, начиная с релиза 6 Maple. Детальнее с оформлением диагностических сообщений для ERROR-функции (error-предложения) можно ознакомиться в справке по пакету.

При этом, значения Vk-выражений из ERROR-функции (Msg для error-предложения) помещаются в глобальную lasterror-переменную пакета и доступны для последующей обработки возникшей процедурной ошибки, которая с точки зрения Maple-языка в общем случае может и не быть ошибочной, как это иллюстрирует следующий фрагмент:

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

> plot(x);

Plotting error, empty plot

> lasterror, lastexception; ⇒ lasterror, lastexception

> ulibrary(8, `C:/AVZ/AGV\\VSV/Art\\Kr`, MKDIR); Error, During delete of MKDIR - could not open help database

> lasterror, lastexception; ⇒ lasterror, lastexception

Следует отметить, что к сожалению пакет Maple не отражает в переменных lasterror и lastexception целый ряд весьма существенного типа ошибочных ситуаций, связанных, прежде всего, с графическими объектами (а в общем случае со средствами GUI пакета), как это весьма наглядно иллюстрирует предыдущий достаточно простой фрагмент. В свою очередь, это же не позволяет обрабатывать такого типа ошибки средствами пакета. При этом, другого типа недоработки Maple иначе как «чехардой» назвать и вовсе трудно. В частности, доступ к отсутствующему файлу или каталогу для релизов 6–9 пакета инициирует ошибочную ситуацию "file or directory does not exist", тогда как в релизе 10 возвращается несколько иная диагностика такой ситуации "file or directory, %1, does not exist". Диагностика ошибочной ситуации "wrong number (or type) of parameters in function …" релизов 6 – 9 пакета Maple изменена в релизе 10 на диагностику "invalid input: …". Серьезными причинами такие замены объяснить трудно. Указанные моменты потребовали очередной корректировки нашей Библиотеки [41,103], например, путем корректировки try-предложения, а именно:

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

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

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

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

Процедура VK программно обрабатывает ситуацию получения как NULL-значения, так и аргумента некорректного типа на основе error-предложения с возвратом соответствующей диагностики, которая вне тела процедуры может обрабатываться программно.

Особенности и полезные рекомендации по использованию функции ERROR (error-предложения) для организации дополнительных выходов из процедур достаточно детально представлены в наших книгах [12-14,39,41]. Здесь же мы лишь сделаем одно замечание относительно реализации функций {RETURN, ERROR} и предложений {return, error}. В настоящее время данные средства попарно функционально эквивалентны, однако синтаксис их использования при создании процедур и программных модулей различен, а именно. В пакете Maple 5 и ниже использовались функции RETURN и ERROR, что в силу их концепции позволяло использовать их в любой точке, подобно обычным функциям. Во многих случаях это представляется весьма удобным. Однако, начиная с Maple 6, пакет, одновременно допуская указанные функции и предложения, между тем, настоятельно рекомендует использовать все же последние, чей синтаксис существенно уже. Вероятно, возможен вариант исключения функций из последующих релизов, что создаст еще один аспект несовместимости релизов уже на уровне исходных текстов. Такой подход несколько настораживает и порождает два естественных вопроса, а именно: (1) почему при проектировании встроенного языка – базовой компоненты пакета – не были решены столь важные концептуальные моменты (это наводит на мысль об отсутствии концептуальной целостности пакета), и (2) если будут удалены указанные средства, то нарушится одно из краеугольных требований, которым должно удовлетворять качественное ПО – совместимость «снизу-вверх» на уровне встроенного языка пакета. Все это вызывает определенные недоумения и опасения со стороны пользователей.

Наконец, по вызову функции traperror(<Выражение>) возвращается результат вычисления выражения, указанного ее фактическим аргументом; если при этом в процессе вычисления возникает ошибочная ситуация, то возвращается идентифицирующее ее диагностическое сообщение, доступное для последующей обработки и не нарушающее естественный порядок вычислений. Таким образом, traperror-функция в отличие от функции ERROR (error-предложения) и результата стандартной обработки ошибочной ситуации не прекращает выполнения процедуры, а позволяет “блокировать” ошибочную ситуацию, предоставляя возможность более гибкой ее обработки. Простой фрагмент иллюстрирует вышесказанное:

В данном фрагменте Н-процедура использует traperror-механизм для обработки особой ситуации, которая может приводить к аварийному завершению процедуры в период ее выполнения - нулевая сумма значений ее фактических аргументов инициирует ошибочную ситуацию `division by zero`. Данная ситуация обрабатывается traperror-функцией во избежание стандартной обработки Maple и обеспечивает пользовательскую обработку, хорошо усматриваемую из листинга процедуры.

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

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

Механизм try-предложения пакета. Для программной обработки ошибочных ситуаций, отражаемых в lasterror-переменной пакета, Maple-язык располагает встроенной функцией traperror, рассмотренной выше, и процедурами stoperror и unstoperror, наряду с try-предложением. Три первых средства остались в наследство от предыдущих релизов пакета (заинтересованный читатель детально с ними может ознакомиться, например, в [1012]), тогда как try-предложение явилось дальнейшим и более эффективным средством обработки ошибочных ситуаций. Данное средство впервые было включено в Maple 6.

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

try <Блок А Maple-предложений>

{catch "Строка соответствия 1": <последовательность Maple-предложений>}

=========================================================

{catch "Строка соответствия n": <последовательность Maple-предложений>}

{finally <последовательность Maple-предложений>} end try {:|;}

Формат предложения try указывает, что его блоки catch и finally необязательны. Более того, catch-блок имеет довольно простую структуру, а именно: "Строка соответствия": <последовательность Maple-предложений>. Механизм выполнения try-предложения сводится вкратце к следующему. После получения управления try-предложение инициирует выполнение блока А предложений Maple, в которых мы пытаемся локализовать ошибочные (особые) ситуации. Если в процессе выполнения А-блока не возникло таких ситуаций, то выполнение будет продолжено, начиная с Maple-предложений finally-блока, если он был определен. Затем выполнение продолжается с предложения, следующего за закрывающей скобкой `end try` try-предложения.

В случае обнаружения исключительной ситуации в процессе выполнения А-блока его выполнение немедленно прекращается и производится сравнение каждой из catch-строк на соответствие возникшей исключительной ситуации (данная ситуация отражается в переменных пакета lasterror и lastexception). Если такая catch-строка существует, то выполняется последовательность Maple-предложений, соответствующая данному catch-блоку (эти предложения расположены между ключевым словом catch и элементами try-предложения, а именно (1) следующий catch-блок, (2) finally-блок либо (3) закрывающая скобка «end try»). В данном случае предполагается, что исключительная ситуация распознана и обработана. Иначе исключительная ситуация предполагается необработанной и ее обработка передается вне try-предложения. При этом, найденный catch-блок может содержать функцию ERROR (error-предложение) без аргументов, которая также передает обработку исключительной ситуации вне try-предложения. Если исключительная ситуация передается вне try-предложения, то создается новый специальный объект, который повторяет имя текущей процедуры, текст диагностического сообщения, а также параметры исходной исключительной ситуации.

Предложение try может содержать любое количество catch-блоков и в каждом из этих блоков выполняется соответствующая последовательность Maple-предложений. Для иллюстрации вышесказанного и механизма активации catch-блоков рассмотрим реализацию некоторой кусочно-определенной функции посредством try-предложения (предыдущий фрагмент); в качестве строк совпадения catch-блоки используют диагностику по запрограммированным ошибкам, сформированным на основе предложений error и return. На наш взгляд, данный фрагмент достаточно прозрачно иллюстрирует механизм инициирования catch-блоков, обеспечивающий достаточно широкий спектр приложений try-предложения для обработки различного типа исключительных (особых) ситуаций, возникающих как естественным образом при выполнении некоторого вычислительного алгоритма или работы с внешними данными и т.д., так и созданных пользователем с целью обеспечения ветвления выполнения алгоритма в зависимости от тех или иных условий, заранее предусмотренных.

При нормальных условиях предложения finally-блока выполняются всегда, как только try-предложение потеряет управление. Данное поведение сохраняется даже, если предложения catch-блока обеспечивают обработку исключительной ситуации вне try-предложения, сгенерированной некоторой новой исключительной ситуацией, или выполнением любого из предложений return, break, next языка пакета. Если исключительная ситуация возникает в catch-блоке и она распознана отладчиком (debugger), то программа пользователя прекращает выполнение и предложения finally-блока не выполняются. Предложения finally-блока не выполняются и в том случае, если возникает одна из следующих исключительных ситуаций:

(1) вычисление превысило отведенный временной интервал (эта ситуация может быть обработана только в том случае, если timelimit-функция, ограничивающая время вычисления, инициирует прерывание типа «time expired», которое может быть опознано и обработано); (2) вычисление прервано извне вычислительного процесса (клавиши Ctrl+C, Break и т.д.);

(3) возникла внутренняя системная ошибка;

(4) неудачное выполнение ASSERT-функции или типификации локальной переменной;

(5) переполнение пакетного стэка.

Ошибка, возникающая в процессе упрощения try-предложения, не может быть распознана и finally-блок (если такой был определен) не выполняется, поэтому try-предложение не может быть выполнено в данной точке. При этом, если исключительная ситуация возникает в процессе выполнения catch-блока или finally-блока, то она рассматривается как возникшая вне области try-предложения. При проверке на совпадение строки соответствия catch-блока с диагностикой исключительной ситуации используются следующие соглашения пакета:

• строки соответствия рассматриваются как префиксы текстов сообщений, генерируе- мых исключительными ситуациями (переменные lastexception и lasterror);

• ни специальный объект, созданный ERROR-функцией (error-предложением), ни строки соответствия catch-блока не вычисляются;

• если строка соответствия имеет длину n, то текст, сгенерированный ERROR-функци- ей либо error-предложением, сравнивается только в пределах его первых n символов;

• отсутствующая строка соответствия сопоставима с любой исключительной ситуацией;

• в try-предложении catch-блок с конкретной строкой соответствия может быть только в единственном числе.

Результатом выполнения try-предложения является результат выполнения его последнего Maple-предложения. Таким образом, механизм try-предложения носит наиболее общий характер, обеспечивая возможность обработки, практически, любой исключительной ситуации, инициированной как ERROR-функцией (error-предложением) на основе конкретного вычислительного алгоритма, так и другими средствами пакета. В нашей книгах [41,103] представлен целый ряд интересных применений try-предложения для обработки различного типа ошибочных и особых ситуаций. Использованные в них приемы могут оказаться весьма полезными для программирования приложений в Maple.

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

WARNING({Msg {, p1, p2, …, pn}})

где Msg и pk – полностью соответствуют описанию error-предложения, представленного в начале данного раздела с очевидной заменой диагностического типа сообщения Msg на информационное. В случае установки параметра warnlevel=0 (по умолчанию warnlevel= 3) процедуры interface вывод сообщений не производится и вызов WARNING подавляется. Следующий простой фрагмент иллюстрирует вышесказанное:

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

> WARNING("Help database for library <%1> has been created",

"C:/AVZ/AGN\VSV/Art\Kr");

Warning, Help database for library <C:/AVZ/AGNVSV/ArtKr> has been created

> _warning;

"Help database for library <C:/AVZ/AGNVSV/ArtKr> has been created"

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

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

3.7. Расширенные средства Maple-языка для работы с процедурами

Рассмотрим теперь вопросы использования механизма процедур несколько детальнее, учитывая прикладную значимость процедур для разработки различных приложений в Maple. Прежде всего, рассмотрим вопрос создания вложенных процедур, т.е. процедур, определения которых, в свою очередь, содержат определения других процедур. В целом ряде случаев данная возможность может оказаться достаточно эффективным средством при программировании прикладных задач. В общем случае поименованная процедура наряду с общепринятым допускает и определение посредством следующей (часто весьма удобной) вычислительной конструкции: assign(<Id-процедуры> {,|=} proc() ... end proc)

эквивалентной рассмотренной выше стандартной конструкции Id := proc( ) ... end proc. Данное обстоятельство позволяет использовать определение процедуры не только внутри другой процедуры, но и внутри вычислительных конструкций, например:

> assign(A, proc() local k; sum(args[k], k=1..nargs) end proc); A(59, 64, 67); ⇒ 190

> [assign(G, proc(x, y) evalf(sqrt(x^2 + y^2)) end proc), G(42, 47)]; ⇒ [63.03173804]

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

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

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

Второй пример представляет вложенную WM1-процедуру, возвращающую результат вызова одной из подпроцедур (AG, AV) в зависимости от значения третьего фактического z-аргумента, передаваемого внешней процедуре. При этом, для текущего сеанса обе подпроцедуры носят локальный характер, т.е. доступны лишь в рамках содержащей их внешней WM1-процедуры. Наконец третий пример представляет вложенную WM2-процедуру, эквивалентную предыдущей, но лишь с той разницей, что входящие в нее подпроцедуры AG, AV определены глобальными. Результат последующих вызовов процедур WM2, AG, AV иллюстрирует вышесказанное.

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

Таблица 8

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

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

Таким образом, Maple-язык позволяет создавать вложенные процедуры, для которых поддерживается не только возможность определения одной процедуры в теле другой, но и возврат процедурой другой процедуры в качестве ее выхода. Поддерживаемый Mapleязыком механизм вложенных процедур (lexical scoping) обеспечивает доступ вложенных процедур к переменным, находящимся в окружающих их процедурах. Этот аспект лежит в основе обеспечения механизма инкапсуляции, на котором базируется современное объектно-ориентированное программирование. При этом, для глобальных переменных поддерживается только режим их разделения вложенными процедурами.

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

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

При этом, кажущаяся «вложенность» следующего типа

P:= proc() global P; P:= proc() end proc; [args] end proc:

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

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

В свете вышесказанного довольно полезной представляется процедура intproc(P), обеспечивающая проверку процедуры Р быть главной или вложенной/внутренней. Успешный вызов процедуры возвращает последовательность из двух списков, первый из которых определяет процедуры текущего сеанса, идентичные исходной процедуре Р, тогда как второй список определяет процедуры, содержащие процедуру Р (или идентичную ей) в качестве внутренних/вложенных процедур. Первый элемент обоих списков – analogous и innet – определяет тип содержащихся в них элементов – аналогичная (главная либо внутренняя/вложенная, но глобальная) и внутренняя/вложенная соответственно. Нижеследующий фрагмент представляет исходный текст процедуры и примеры ее применения.

Если в качестве фактического аргумента Р выступает символьное выражение, то вызов процедуры возвращает FAIL-значение по причине невозможности установить истинное определение символа (возможно, процедура из библиотеки, логически не сцепленной с главной Maple-библиотекой). В случае типа аргумента Р, отличного от `procedure`, возникает ошибочная ситуация. Процедура intproc имеет ряд достаточно интересных приложений.

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

CompSeq(locals = L1, globals = L2, params = L3, <Список ВК>)

где в качестве первых трех необязательных аргументов выступают списки соответственно локальных (L1), глобальных (L2) переменных ВП и параметров (L3). Если локальные переменные областью своего определения имеют только тело ВП, то глобальные - текущий сеанс, а параметры могут передаваться в ВП извне ее, как и воспринимаемые извне значения ее глобальных переменных. Последний обязательный аргумент CompSeq-функции представляет собой список вычисляемых конструкций (ВК) вида <Id-переменной> = <Выражение>; последняя ВК последовательности и возвращает окончательный результат ее вычисления. При этом, ВП может быть упрощена, оптимизирована, а также конвертирована в форму процедуры, и наоборот. Следующий фрагмент иллюстрирует использование CompSeq-функции для создания ВП, затем конвертацию полученной конструкции в Maple-процедуру с ее последующим ее выполнением:

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

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

userinfo(<Уровень>, <Id>, <Выражение_1> {, ... , <Выражение_n>})

и позволяющую в соответствии с указанным уровнем выводить информацию, представляемую ее аргументами, начиная с третьего (обязательного), для процедур, чьи идентификаторы задаются вторым аргументом функции, допускающим как отдельное имя, так и их множество. Вывод информации, получаемой в результате вычисления выражений_к, производится только в том случае, если определенный первым аргументом функции уровень не превышает установленного в infolevel-таблице для ее all-входа. Исходным состоянием таблицы является: print(infolevel); ⇒ table([hints=1])). Ее единственный hintsвход определяет вывод результата вызова функции/процедуры невычисленным, если невозможно получить его точное значение. Вычисленные выражения userinfo-функции выводятся в lprint-формате, разделенные тремя пробелами.

Предложение infolevel[all]:=m определяет общий уровень вывода для всех последующих процедур, содержащих userinfo-функцию. Соответствующая информация выводится только тогда, когда определяемый их первым аргументом уровень не превышает указанного в предложении infolevel уровня m, например:

В частности, библиотечные процедуры пакета используют следующие информационные уровни вывода: (1) - обязательная информация; (2, 3) - общая информация, включая метод решения проблемы, и (4, 5) - детальная информация по процедуре.

При отсутствии для процедур общего уровня вывода информации он определяется на основе индивидуальных infolevel-предложений, кодируемых либо в теле самих процедур, либо вне их в виде infolevel[<Имя процедуры>]:= Уровень. По данному предложению соответствующая информация заносится в infolevel-таблицу, с которой работают функции userinfo процедур. Последний пример предыдущего фрагмента иллюстрирует сказанное. Средство userinfo-функции довольно полезно для обеспечения пользователя документированными процедурами.

В случае определения выхода процедуры через RETURN-функцию (return-предложение) следует кодировать предложения infolevel и userinfo перед ним, ибо в противном случае действие последних подавляется, как это иллюстрирует следующий простой фрагмент:

> infolevel[all]:= 10; ⇒ infolevel[all] := 10

> P1:= proc() local infolevel; userinfo(5, P1, `Суммирование `||nargs||` аргументов`); `+`(args); end proc:

> P2:= proc() local infolevel; return `+`(args); userinfo(5, P2, `Суммирование `||nargs||` аргументов`); end proc:

> P1(10, 17, 39, 44, 59, 64); ⇒ 233

P1: Суммирование 6 аргументов

> P2(10, 17, 39, 44, 59, 64); restart: ⇒ 233

> P1:= proc() local infolevel; infolevel[P1]:= 10: userinfo(2, P1, `Суммирование `||nargs||` аргументов`); `+`(args); end proc:

> P2:= proc() global infolevel; infolevel[P2]:=10: userinfo(2, P2, `Суммирование `||nargs||` аргументов`); `+`(args) end proc:

> P1(10, 17, 39, 44, 59, 64); print(infolevel); ⇒ 233 table([hints = 1])

> P2(10, 17, 39, 44, 59, 64); print(infolevel); ⇒ 233 table([hints = 1, P2 = 10])

P2: Суммирование 6 аргументов

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

Для обеспечения мониторинга основных вычислительных ресурсов, затребованных при выполнении процедур/функций, служит группа profile-процедур, позволяющих получать оперативную информацию по выполнению указанных процедур или функций в разрезе: количество вызовов, временные издержки, требуемая оперативная память и др. Информация выводится в табличном виде, смысл которой особых пояснений не требует. Для инициации режима мониторинга процедур/функций используется процедура profile(P1, ..., Pn), которая в случае успешного вызова возвращает значение NULL и по которой устанавливается режим мониторинга вызовов Pj-процедур, определяемых ее фактическими аргументами. При этом, следует иметь в виду, что попытка вызова процедуры profile для уже находящейся в режиме profile-мониторинга процедуры либо функции вызывает ошибочную ситуацию, как это иллюстрирует пример нижеследующего фрагмента. По вызову profile() производится мониторинг вызовов всех процедур и функций в текущем сеансе. Однако, в таком объеме profile-средство рекомендуется использовать с большой осторожностью во избежание существенных замедления вычислений и увеличения используемой памяти, вплоть до критического.

Результаты мониторинга носят кумулятивный характер и их можно периодически выводить по showprofile({ |P1,...,Pn})-процедуре в разрезе или всех профилируемых процедур, или только относительно Pj-указанных в качестве фактических аргументов процедуры. По вызову unprofile({|P1 ,..., Pn})-процедуры производится прекращение режима мониторинга в разрезах, аналогичных предыдущей процедуры. Результатом успешного вызова unprofile-процедуры является возврат NULL-значения, удаление профильной информации и прекращение режима мониторинга по соответствующим процедурам или функциям. Повторное применение unprofile-процедуры вызывает ошибочную ситуацию. Следующий фрагмент иллюстрирует применение рассмотренных средств для мониторинга пользовательской VSV-процедуры и некоторых встроенных функций языка.

function depth calls time time% bytes bytes% ------------------------------------------------------------------------------------ sin 1 3 .016 100.00 16172 35.00 exp 1 2 0.000 0.00 6140 13.29 VSV 1 3 0.000 0.00 23896 51.71 ------------------------------------------------------------------------------------ total: 3 8 .016 100.00 46208 100.00

> unprofile(): showprofile(); function depth calls time time% bytes bytes%

------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------- total: 0 0 0.000 0.00 0 0.00

С учетом сказанного особых пояснений примеры фрагмента не требуют. Близкой по назна-чению к profile-процедуре является и exprofile-процедура, обеспечивающая мониторинг всех вызовов пакетных процедур и функций. С другими типами мониторинга различных аспектов выполнения процедур и/или функций в среде Maple-языка можно ознакомиться в [31, 33,43,84,103]. Рассмотренные средства мониторинга предоставляют полезную информацию, в частности, для оптимизации вычислений.

Создав собственную серьезную процедуру с использованием других своих и пакетных процедур и функций, поместив ее в свою библиотеку, естественно возникает задача ее оптимизации, в частности, с целью раскрытия частоты использования средств, содержащихся в ней, и основных компьютерных ресурсов, используемых ими. В этом контексте, проблема оптимизации пользовательских процедур весьма актуальна. Для этих целей достаточно полезной представляется процедура StatLib(L) [103], обеспечивающая сбор основной статистики по заданной L-библиотеке и возврату статистики для последующего анализа. В процессе своего выполнения StatLib-процедура требует некоторых дополнительных ресурсов памяти и времени. Подробнее о ней будет идти речь при рассмотрении создания библиотек пользователя.

В заключение настоящего раздела отметим, что более искушенный пользователь может при работе с процедурами воспользоваться специальными двумя процедурами procbody и procmake. По вызову процедуры procbody(P) возвращается специальная невычисленная форма процедуры с P-именем, которая может быть протестирована и модифицирована, не затрагивая исходной P-процедуры. Обратной к ней является процедура procmake(G), возвращающая на основе специальной G-формы выполняемую Maple-процедуру. Следующий простой фрагмент иллюстрирует вышесказанное:

Использование данных функций предполагает достаточную искушенность пользователя по работе в среде Maple-языка, поэтому за детальной информацией заинтересованный читатель отсылается к интересным работам, цитированным в книгах [12,13].

Отметим теперь некоторые принципиальные новации относительно процедур, появившиеся в последнем релизе 10. Во-первых, как правило, количество передаваемых процедуре при вызове фактических аргументов не обязательно должно совпадать с количеством ее формальных аргументов. Однако, если при определении процедуры в конце ее формальных аргументов закодирован символ-маркер «$», то передача процедуре при вызове дополнительных фактических аргументов вызывает ошибочную ситуацию с диагностикой "invalid input: %1 arguments passed to %2 but only %3 positional parameters specified", как это весьма наглядно иллюстрирует следующий простой фрагмент:

> P:= proc(x, y, z, $) `+`(args) end proc: P(64, 59, 39), P(64, 59); # Maple 10 ⇒ 162, 123 > P(64, 59, 39, 10, 17);

Error, invalid input: 5 arguments passed to P but only 3 positional parameters specified

> lasterror;

"invalid input: %1 arguments passed to %2 but only %3 positional parameters specified" > P:= proc(x, y, z, $) `+`(args) end proc: P(64, 59, 39), P(64, 59); # Maple 6 – 9 Error, `$` unexpected

> lasterror; ⇒ lasterror

Тогда как в предыдущих релизах 6 – 9 данная новация вызывает ошибочную ситуацию уже на уровне синтаксиса, не отображаясь в lasterror-переменной. Принципиально, данная новация не столь уж существенна, добавляя пакету несовместимость «сверху-вниз» (в принципе, каноны программирования это допускают, но все же). Тем более, что контроль за передаваемыми процедуре фактическими аргументами легко осуществляется программно и на основе сути реализуемого ею алгоритма с использованием nargs-переменной.

Дополнительно к двум процедурным переменным args и nargs, рассмотренным выше, в релизе 10 введен ряд дополнительных процедурных переменных, а именно:

_passed – алиас для переменной args

_params – последовательность продекларированных позиционных аргументов, передан- ных процедуре

_options – последовательность опций в процедуре

_rest – последовательность недекларированных аргументов, переданных процедуре _npassed – алиас для переменной nargs

_nparams – число продекларированных позиционных аргументов, переданных процедуре

_noptions – число опций в процедуре

_nrest – число недекларированных аргументов, переданных процедуре

_nresults - число предполагаемых выходов из процедуры

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

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

3.8. Расширение функциональных средств Maple-языка пакета

Многие встроенные и библиотечные процедуры Maple допускают пользовательские расширения, увеличивающие область применения данных средств. Например, можно определять новые типы и преобразования, расширять диапазон математических функций, обрабатываемых функциями evalf и diff, расширяя тем самым средства главной Maple-библиотеки. Каждое уникальное расширение средства (типа type либо diff) ассоциируется с именем. Это имя определяет имя расширяемого средства, например, для type это – type. Существуют два механизма расширения: классический механизм расширения, используемый в большинстве случаев, и современный механизм расширения, используемый более новыми средствами, например, пакетный модуль TypeTools (начиная с Maple 8), содержащий 5 процедур для расширения множества типов, распознаваемых функцией type пакета, играющей важную роль при типизации объектов пакета.

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

Все встроенные процедуры и большинство библиотечных процедур, допускающие пользовательские расширения, используют классический механизм, основанный на конкатенации имен, а именно. Расширяемой процедуре name дают новые функциональные возможности, определяя выражение (как правило, процедура) с именем формата `name/new`, где new – имя расширения. Например, новый тип для бинарных выражений (распознаваемый type-функцией) может быть определен процедурой с именем `type/binary`. При этом, вводимые расширения для стандартного средства name должны удовлетворять определенным правилам, которым удовлетворяет данное средство name, и которые отражены в справке по данному средству. Например, при расширении стандартной type-функции процедурой с именем `type/aa` требуется, чтобы она возвращала только значения {true, false}, в противном случае инициируется ошибка с диагностикой "result from type `%1` must be true or false", например:

> `type/aa`:=proc(x::numeric) if x<0 then true elif x>0 then false else FAIL end if end proc:

> type(0, 'aa');

Error, result from type `aa` must be true or false

> lasterror; ⇒ "result from type `%1` must be true or false"

В качестве примера расширения стандартной type-функции определим новый тип color, отсутствующий в пакете текущих релизов и достаточно полезный для большого числа задач, имеющих дело с графическими объектами. Вызов процедуры type(x, 'color') возвращает значение true, если x – имя цвета, процедура либо выражение, которые можно рассматривать в качестве цвета при формировании графического объекта; в противном случае возвращается false-значение. При этом, через глобальную _ColorType-переменную возвращается 2-элементный бинарный список, если вызов процедуры type(x, 'color') возвращает true-значение. Его первый и второй элементы определяют допустимость xвыражения в качестве цвета (0 – нет, 1 – да) при оформлении графического объекта с опцией color = x в случае размерности 2 и 3 соответственно. Если же вызов процедуры возвращает false-значение, то переменная _ColorType возвращается неопределенной. Процедура `type/color` имеет целый ряд полезных приложений, однако ее применение предполагает дополнительную проверку через глобальную переменную _ColorType из-за различий механизмов раскраски для 2- и 3-мерных графических объектов. Ниже приведены исходный текст процедуры `type/color` и примеры ее применения. global _ColorType;

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

> &ma('x', 'y', 'z', 'g', 'h', 2006); x, y, z, g, h; ⇒ 2006, 2006, 2006, 2006, 2006

> ('x', 'y', 'z', 'g', 'h') &ma _NULL; x, y, z, g, h;

> ('x', 'y', 'z', 'g', 'h') &ma 2006; x, y, z, g, h; ⇒ 2006, 2006, 2006, 2006, 2006

> ('x', 'y', 'z', 'g', 'h') &ma (sin(a)*cos(b)); x, y, z, g, h;

sin(a) cos(b), sin(a) cos(b), sin(a) cos(b), sin(a) cos(b), sin(a) cos(b) > ('x', 'y', 'z', 'g', 'h') &ma ((a+b)/(c-d)); x, y, z, g, h;

a + b a + b a + b a + b a + b

, , , ,

c − d c − d c − d c − d c − d

Первый пример фрагмента представляет расширение тестирующей type-функции на новый тип float_list, определяющий списочную структуру с элементами float-типа. С этой целью идентификатору `type/<Id>` присваивается определение процедуры, вызываемой в тот момент, когда делается попытка протестировать произвольное выражение посредством вызова type(Выражение, float_list). В остальных случаях применяется вызов встроенной type-функции пакета. Представленная процедура тестирует, в первую очередь, на соответствие типа выражения типу list и в случае наличия такого соответствия на втором этапе тестирует на соответствие типа каждого элемента списка float-типу, возвращая в зависимости от наличия/отсутствия такого соответствия true/false-значение.

Во втором примере определяется модификация стандартного complex-типа. Вызов стандартной функции type(Z, complex) возвращает true-значение, если Z – выражение формы x + y*I, где x (если существует) и y (если существует), конечны и типа 'realcons'. При этом, вызов процедуры type(X, complex(t)) возвращает true-значение, если Re(X) (если существует) и Im(X) (если существует) – оба типа t. К сожалению, стандартная процедура не обеспечивает, на наш взгляд, корректного тестирования Maple-выражений упомянутого complex-типа, включая в него и действительные выражения. Следующий простой пример убедительно подтверждает вышесказанное, а именно:

> map(type, [-9.1942, 64, 350, -2006, 10/17], 'complex'); ⇒ [true, true, true, true, true]

К сожалению, эта серьезная ошибка имеет место для всех релизов Maple, начиная с шестого. Процедура 'type/complex1' имеет те же самые формальные аргументы как и стандартная процедура и устраняет ошибки, свойственные второй. Кроме того, она обеспечивает более широкую проверку Maple-объектов complex-типа. Между тем, процедура не различает числовые типы {fraction, rational}, идентифицируя их более общим numericтипом. В отличие от стандартной процедуры, процедура 'type/complex1' обеспечивает более корректную проверку выражений Maple на complex-тип. Приведенные примеры иллюстрирую применение как стандартной, так и 'type/complex1'-процедуры.

В третьем примере определяется расширение convert-функции Maple-языка на случай конвертации символов строчного значения в их заглавный эквивалент. В данном случае вызов функции convert(`Строка`, 'uppercase') инициирует вызов `convert/uppercase`-процедуры, обеспечивающей соответствующую конвертация указанной строки.

В конструкции lhs: = rhs оператор назначения `:=` присваивает lhs выражение rhs. Кроме того, оператор назначения допускает многократные назначения. Однако, в этом случае количество элементов последовательности lhs должно строго соответствовать количеству элементов последовательности rhs, иначе возникает ошибка с диагностикой "Error, ambiguous multiple assignment". Тогда как в ряде случаев возникает необходимость назначения того же самого выражения достаточной длинной последовательности имен или вызовов функций.

Данная проблема решается оператором &ma, который имеет идентичный с оператором `:=` приоритет. Оператор &ma имеет два формата кодирования, а именно: процедурный и операторный. Вообще говоря, в обоих случаях элементы lhs должны быть закодированы в невычисленном формате. Исключение – только самое первое назначение. Кроме того, в операторном формате, левая часть lhs должна быть закодирована в скобках. Кроме того, если правая часть rhs удовлетворяет условию type(rhs, {`..`, `<`, `<=`, `.`, `*`, `^`, `+`, `=`}) = true, то правая часть должна быть также закодирована в скобках. Наконец, если необходимо присвоить NULL-значение элементам левой части lhs, то в качестве rhs кодируется _NULL-значение. Успешный вызов процедуры &ma либо применения оператора &ma возвращает NULL-значение с выполнением указанных назначений. В целом ряде приложений оператор &ma оказывается достаточно полезным.

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

Наряду со стандартно определяемыми, Maple-язык допускает пользовательские операторы (в терминологии пакета называемые нейтральными операторами), идентифицируемые ключевыми словами вида &<символ>, при этом символ кодируется без верхних кавычек и не должен содержать следующих символов:

& | ( ) [ ] { } ; : ‘ ` # % \ пробел перевод строки

Длина &-цепочки символов не должна превышать 495. Сам Maple-язык использует такого типа оператор &* для представления некоммутативного произведения, тогда как все другие идентификаторы &<символ> описанного формата рассматриваются пакетом в качестве ключевых слов для идентификации пользовательских операторов.

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

`&<Символ>` := proc(x, y, z, ...) ... end proc {:|;}

при этом, в случае одного формального аргумента получаем унарный префиксный оператор, двух аргументов – бинарный инфиксный оператор и более двух – n-арный (n ≥ 3) префиксный оператор; в любом из этих случаев определен вызов &<Символ>(x, y, z, ...). Более того, Maple-язык не накладывает на пользовательские операторы специальной семантики и рассматривает идентификатор оператора в качестве имени сооответствующей пользовательской процедуры. В общем случае, пользовательский оператор является n-арным префиксным оператором либо вызовом n-арной функции, т.е. следующие две конструкции эквивалентны в среде Maple-языка, а именно:

&<Символ> (x1, x2, ..., xn) ≡ &<Символ>(x1, x2, ..., xn) (n ≥ 1)

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

Первый пример представляет унарный префиксный &Cs-оператор, применение которого к комплесному числу возвращает сопряженное ему число. Второй пример представляет бинарный инфиксный &Kr-оператор, определенный над двумя числовыми значениями и возвращающий значение, вычисляемое по указанной формуле. Наконец, третий пример представляет n-арный префиксный &Art-оператор, обеспечивающий над выражениями вычислительную процедуру также формульного характера. Каждый из приведенных примеров иллюстрирует применение соответствующего оператора как в традиционной для него нотации, так и в форме вызова соответствующей ему процедуры. Таким образом, в среде Maple-языка пользовательский (нейтральный) &-оператор представляется вызовом соответствующей процедуры. При этом, инфиксная нотация допустима лишь для случая двух операндов, тогда как префиксная – для любого числа операндов. Описанный метод определения пользовательских операторов с учетом механизма процедур Maple-языка довольно прозрачен и имеет важное прикладное значение, позволяя вводить собственные &-операторы для специальных операций. В качестве одного из таких приложений рассмотренного метода уже был приведен пример &ma оператора, приведем еще пару полезных примеров.

Вышеприведенный фрагмент иллюстрирует применение описанного способа для реализации пользовательского оператора сдвига `&Shift` для функции от нескольких переменных, определяемого следующим соотношением:

&Shift (G, [h1, h2, ..., hn], x1, x2, ..., xn) ⇒ G(x1 + h1, x2 + h2, ..., xn + hn)

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

Тогдда как второй пример фрагмента представляет процедуру lop3(O, x, y), поддерживающую следующие четыре операции (О) 3-значной логики над переменными (x, y) из множества {0, 1, 2}, а именно: Inv – инверсия, Dis – дизъюнкция, Con – конъюнкция и Webb – функция Вебба. Данная процедура может быть довольно несложно расширена и на другие операции 3-значной логики (а в общем случае и к-значной), что позволит использовать ее для представления любых многозначных функций алгебры логики. Читателю в качестве весьма полезного упражнения рекомендуется, используя описанный метод, запрограммировать несколько &-операторов и процедур, определяющих какиелибо интересные нестандартные операции над данными и/или структурами данных, как рассмотренных, так и других практически полезных типов.

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

Данный простой прием можно применять как для создания пользовательских модулей, так и для организации отложенных определений процедур, что в целом ряде случаев позволяет создавать более эффективные программные Maple-средства [8-14,29,41,103].

3.9. Иллюстративные примеры оформления Mapleпроцедур

Представленное выше описание структурной организации Maple-процедуры иллюстрируется нижеследующими примерами, отражающими основные ее элементы и принципы, что позволяет непосредственно приступать с учетом ранее рассмотренного материала к созданию, на первых порах, относительно несложных пользовательских процедур различного назначения. В основу иллюстративных примеров положим ряд процедур из нашей Библиотеки [41,103,109], содержащих практически полезные приемы программирования в среде Maple-языка. Наряду с этим, примеры представляют процедуры, имеющие непосредственный прикладной интерес при программировании приложений.

В ряде случаев для упрощения разработки Maple-приложений (например, для обеспечения их совместимости относительно релизов) мы вынуждены одновременно открывать несколько релизов в текущем сеансе Windows. В этой связи вполне естественным представляется вопрос программного тестирования наличия релизов Maple в текущем сеансе работы с операционной средой. Данная задача решается процедурой mapleacs, исходный текст и примеры применения которой представляет следующий фрагмент. Успешный вызов процедуры mapleacs() возвращает вложенный список, подсписки которого имеют {2|3} элемента в зависимости от релиза пакета и его клона.

Первый элемент такого подсписка определяет релиз и его клон. Например, Maple9s определяет релиз Maple 9 для ядра 'maplew9.exe' (стандартный режим) и Maple9 для ядра пакета 'cwmaple9.exe' (классический режим). Тогда как второй элемент подсписка определяет имя либо полный путь к текущему Maple-документу соответствующего релиза, тогда как третий элемент (при его наличии) подсписка определяет номер сервера. Процедура mapleacs представляется достаточно полезным средством при нескольких одновременно загруженных релизах (могут быть и одинаковыми) в текущий сеанс Windows.

В качестве еще одного примера приведем процедуру `convert/proc`, иллюстрирующую как подход к расширению стандартных средств пакета, так и полезную в практическом отношении. Процедура обеспечивает конвертирование равенства или их списка/множества в процедуру или список/множество. При этом, левые части равенств должны быть функциями вида f(x, y, z, ...), тогда как правые – любыми алгебраическими выражениями. В случае одного равенства вызов процедуры convert(x, `proc`) возвращает тело процедуры, в остальных случаях возвращается NULL-значение с обеспечением требуемой конвертации. Следующий фрагмент представляет исходный текст процедуры и примеры ее применения.

Представленная процедура `convert/proc` полезна в целом ряде приложений, например, при работе с дифференциальными уравнениями. В качестве достаточно полезного упражнения рекомендуется рассмотреть организацию этой небольшой процедуры. Ниже будет представлен ряд других процедур, иллюстрирующих те или иные аспекты Mapleязыка. Большое же количество самых разнообразных процедур в исходном виде, использующих немало достаточно полезных, эффективных (а в ряде случаев и нестандартных) приемов программирования в Maple, можно найти в архиве, поставляемом с книгой [41, 103] либо бесплатно скачать архив с Библиотекой с адреса, указанного в [109].

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

Задача решается процедурой, базирующейся на стандартной процедуре anames с использованием некоторых особенностей Maple [41,103,109]. Вызов процедуры nvalue(v) возвращает список глобальных имен, которым в текущем сеансе было присвоено выражение v, тогда как вызов nvalue() возвращает список глобальных имен, которым в текущем сеансе присваивалось NULL-значение. Вызов процедуры возвращает пустое множество, т.е. {}, если в текущем сеансе таких назначений не производилось.

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

Вызов процедуры Release() возвращает целое число 6, 7, 8, 9, 9.5, 10 или 11 для семи последних релизов пакета и значение`Other release` в противном случае. Если же вызов процедуры Release(h) использует необязательный h-аргумент (имя), через него возвращается полный путь к главному каталогу пакета, как иллюстрирует следующий фрагмент. В отличие от Release, вызов процедуры Release1() возвращает число 6 для 6-го релиза и 7 для релизов 7 – 11 пакета. Это обусловлено причинами, изложенными ниже.

Тогда как вызов Release1(h) через h дополнительно возвращает полный путь к главной библиотеке пакета. При этом, процедура идентифицирует и более ранние релизы 4 и 5 пакета. Данная процедура, прежде всего, представляет несомненный интерес в связи с отсутствием полной совместимости (как «сверху-вниз», так и «снизу-вверх») релизов 6, с одной стороны, и релизов 7–11, с другой стороны. Детально этот вопрос рассмотрен в [41].

В ряде случаев возникает задача определения наличия вызовов заданной функции/процедуры N в некоторой процедуре Proc. Точнее, нас будут интересовать форматы таких вызовов. Данная задача решается процедурой extrcalls, представленной ниже.

Вызов процедуры extrcalls(Proc, N) возвращает список вызовов функции N, используемых процедурой P. Вызовы возвращаюся в строчном формате, дабы не инициировать реальных вызовов вне тела процедуры. В случае отсутствия искомых вызовов инициируется ошибочная ситуация с диагностикой «call of the form <%1> does not exist». Данная процедура имеет целый ряд полезных применений при разработке приложений.

Как уже отмечалось [103], Maple-язык допускает использование встроенной goto-функции безусловных переходов. Поэтому в ряде случаев возникает задача проверки на наличие в процедуре такого типа вызовов. Вызов процедуры isplabel(P) возвращает значение true, если процедура Р использует вызов функции goto; в противном случае возвращается false-значение. Тогда как вызов процедуры isplabel(P, T) с дополнительным Т-аргументом обеспечивает возврат через него множества имен всех меток, обусловленных goto-вызовами в процедуре Р. При этом, процедура обеспечивает проверку меток процедуры Р на допустимость. В случае обнаружения недопустимости выводится соответствующее сообщение. Для обеспечения корректности использования меток может быть использована процедура Lprot [41,103], обеспечивающая присвоение protected-атрибута всем меткам заданной процедуры. Ниже приводится исходный текст isplabel-процедуры и пример ее конкретного применения для тестирования goto-переходов.

Вызов процедуры swmpat(S, m, p, d {, h}) возвращает true-значение тогда и только тогда, когда строка S содержит вхождения подстрок, соответствующих шаблону m с группирующими символами, определенными четвертым d-аргументом.

Тогда как третий фактический р-аргумент задает список кратностей соответствующих вхождений группирующих символов в m-шаблон. Если вызов процедуры swmpat(S, m, p, d, h) использует пятый необязательный h-аргумент и возвращает true-значение, то через h возвращается вложенный список, чьи 2-элементные подсписки определяют первую и последнюю позиции непересекающихся подстрок S, соответствующих m-шаблону. В случае отсутствия в m-шаблоне группирующих символов через h-аргумент возвращается целочисленный список, чьи элементы определяют первые позиции непересекающихся подстрок S, соответствующих m-шаблону. Детально с процедурой swmpat и ее модификацией swmpat1 можно ознакомиться в [41,103,109].

Вызов Red_n(S, G, N) возвращает результат сведения кратных вхождений в строку/символ S символов/строк, определенных G-аргументом, к кратности не большей, чем N.

В частности, при N = {1|2} строка/символ G удаляется из строки/символа S или сохраняется с кратностью 1 соответственно. При этом, тип возвращаемого процедурой Red_n результата соответствует типу S-аргумента. Процедура Red_n производит регистро-зависимый поиск. Если G не входит в S, вызов процедуры Red_n(S, G, N) возвращает первый аргумент S без обработки с выводом соответствующего сообщения. Процедура обрабатывает основные особые и ошибочные ситуации.

Если второй и третий аргументы определяют списки с взаимно однозначным соответствием их элементов, то сведение кратностей производится по всем элементам списка G с соответствующими им кратностями из списка N. При этом, если nops(G) > nops(N), то последние nops(G) - nops(N) элементов из G получают кратность 1 в возвращаемом результате. Если же G – список и N – положительное целое, то все элементы G получают одинаковую кратность N. Наконец, если G – символ либо строка и N – список, то G получает кратность N[1] в возвращаемом результате. Процедура Red_n является довольно полезным средством при работе со строками и символами, используется она и целым рядом средств нашей Библиотеки [41,103,109].

Вызов процедуры deltab(T, r, a) возвращает NULL-значение, т.е. ничего, обеспечивая удаление из таблицы T всех элементов, имеющих соответствие по отношению к выражению a, в зависимости от заданного режима удаления r, а именно: r=0 – равенство входов, r=1 – равенство выходов и r=2 – наличие любого из указанных равенств. Процедура – достаточно полезное средство в ряде приложений, имеющих дело с табличными структурами.

В качестве замены для стандартной assign-процедуры для Maple 6-11 может вполне выступить процедура assign67. Своими возможностями процедура assign67 достаточно существенно расширяет процедуру assign, выполняя те назначения, на которых даже релиз 10 пакета вызывает ошибочные ситуации. Следующий фрагмент представляет исходный текст процедуры и некоторые примеры ее применения.

Процедура assign67, расширяя возможности стандартной assign-процедуры релизов 6 – 10, оперспечивает дополнительно такие операции как множественные присвоения последовательностей значений переменным, множественные присвоения NULL-значений и др. При этом, вызов процедуры assign67 корректен на любом кортеже фактических аргументов, обеспечивая достаточно широкий диапазон типов и вариантов присвоений наряду с непрерывностью вычислений. Лучше всего возможности процедуры assign67 иллюстрируются наиболее типичными примерами ее применения [41,103,109]. Например, вызов процедуры assign67(x1, x2, x3,…), если фактическими аргументами являются символы, делает присвоение x1:= x2, x3, … . Тогда как вызов assign67(x1, x2,…,xk, y=a,…) при том же предположении производит присвоения x1:=NULL,…, xk:=NULL. Уже в настоящей реализации процедура assign67 во многих случаях упрощает программирование в среде Maple-языка, однако она допускает и дальнейшие интересные расширения.

Вызов процедуры type(P, fpath) возвращает true-значение, если аргумент Р определяет допустимый полный путь, и false-значение в противном случае. При этом, следует иметь в виду, что возврат true-значения лишь говорит, что проверяемый каталог Р, вообще говоря, может быть элеменьтом файловой системы компьютера.

Данная процедура хорошо дополняет процедуру `type/path` [41,103] и представляется довольно полезной в ряде задач, имеющих дело с обработкой файлов данных.

В ряле случаев возникает необходимость программной проверки имени текущего документа. Нижеследующая процедура mwsname успешно решает данную задачу.

Успешный вызов процедуры mwsname() возвращает имя текущего документа в symbolформате. При этом предполагается, что в текущем Windows-сеансе инициирован только один Maple-сеанс. Процедура mwsname достаточно полезна при программной обработке текущих Maple-документов.

Для целого ряда задач весьма полезным оказывается вызов процедуры type(P, boolproc).

Вызов процедуры type(P, boolproc) возвращает true-значение, если Р является булевской процедурой (т.е. возвращает только значения true или false), и false-значение в противном случае. Процедура производит тестирование с высокой степенью достоверности. В случае необходимости процедура type(P, boolproc) легко адаптируется на особые типы тестируемых процедур посредством подключения дополнительных catch-блоков.

Вызов процедуры type(F, file) возвращает true-значение, если К – реально существующий файл данных, и false-значение в противном случае. При этом, следует иметь в виду, что возврат false-значения говорит лишь о том, что тестируемый файл не: (1) последний элемент в цепочке каталогов F, (2) в текущем каталоге и (3) среди открытых файлов. Ниже представлен исходный текст процедуры и примеры ее применения.

Между тем, тестируемый файл, вообще говоря, может быть элементом файловой системы компьютера. При этом, через глобальную переменную _datafilestate в случае возврата true-значения возвращается последовательность, чей первый элемент определяет состояние файла {close, open}, тогда как второй элемент для close-состояния определяет полный путь к найденному файлу, а для open-состояния – 2-элементный список, чей первый элемент определяет используемый файлом логический канал в/в, тогда как второй – полный путь к файлу. Средства нашей Библиотеки [41], имеющие дело с доступом к файлам данных, используют именно эту процедуру. Между тем, для более развитого тестирования Maple-объектов на предмет их принадлежности к file-типу предназначена процедура type(F, 'file1'), представленная ниже исходным текстом и примерами применения.

Вызов процедуры type(F, 'file1') возвращает true-значение, если F определяет реальный файл данных и false-значение в противном случае. При этом, следует иметь в виду, что возврат false-значения говорит лишь о том, что тестируемый файл не: (1) последний элемент в цепочке каталогов F, (2) в главном каталоге Maple, (3) в каталоге с Maple-ядром, (4) в каталоге Users и (5) среди открытых файлов. Между тем, тестируемый файл, вообще говоря, может быть элементом файловой системы компьютера. Вызов процедуры не именяет текущих атрибутов и состояния {open|close} тестируемых файлов. Процедура полезна при разработке приложений, имеющих дело с обработкой файлов данных.

Стандартные функции system и ssystem позволяют выполнять целый ряд довольно важных процедур, обеспечивая более эффективное программирование. Однако на некоторых операционных платформах не все системные команды доступны через данный механизм. Как правило, указанные Maple-функции имеют дело с файлами типов {'.exe', '.com'}, стандартно поставляемых с операционной системой. Между тем, множество таких файлов весьма обширно и содержит целый ряд весьма полезных средств, представляющих немалый интерес и при разработке приложений в Maple-среде. Следующие две процедуры com_exe1 и com_exe2 в полной мере решают вопрос пополнения операционной среды требуемыми системными командами. С описанием алгоритмов, реализуемых данными процедурами, можно ознакомиться в [41,103,109].

Первым Р-аргументом вызова com_exe1(P, L) может быть полный путь к файлу данных типа {'.exe', '.com'} с системной командой или {0|1}-значение, определяющее режим проверки глобальной переменной _TABprog, созданной/обновленной процедурой. Вызов com_exe1(0, L) возвращает полные имена программ, сохраненных в таблице _TABprog, находящейся в Maple-библиотеке, адрес которой указан в L. Тогда как вызов процедуры com_exe1(1, L) возвращает список полных имен программ, находящихся в _TABprog и доступных в текущем сеансе. Наконец, вызов com_exe1(P, L) обновляет Maple-библиотеку L программой, полный путь к которой определяется Р-аргументом.

Процедура com_exe2, дополняя предыдущую, предназначена для дозагрузки требуемых программ в главный каталог Windows. Детальнее с данными средствами можно ознакомиться в [41,103] либо в справке по нашей Библиотеке [108,109].

Вызов процедуры E_mail(F, H) обеспечивает выбор корректных email-адресов из текстового файла, указанного первым аргументом F, с помещением их в выходной файл, указанный вторым аргументом Н. При этом, при отсутствии пути к принимающему файлу Н он создается с выводом соответствующего сообщения о созданном пути к Н-файлу.

Путь к файлу Н создается ранее рассмотренной процедурой MkDir [41,103,109]. Результатом выполнения процедуры является не только создание текстового файла с искомыми email-адресами, пригодными для немедленного использования средствами email, но и обеспечение основной статистики, чье назначение легче проясняет фрагмент, представленный выше. При этом, если вызов процедуры E_mail(F, H, h) использует необязательный третий h-аргумент (любое допустимое Maple-выражение), то каждый корректный email-адрес выводится в принимающий Н-файл отдельной строкой; в противном случае адреса разделяются запятой. Все подозрительные адреса (если такие существуют) помещаются в отдельный текстовый $$$-файл, чье главное имя идентично имени исходного F-файла. Процедура выводит и другую полезную статистику о результатах работы.

Процедура email(F, H) базируется на предыдущей процедуре, наследуя два ее первых аргумента и расширяя действие первой на файлы данных типов {doc, rtf, htm}, и в более общем случае на файлы rlb-типа. Фрагмент ниже представляет текст процедуры.

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

Вызов процедуры extexp(S, n) возвращает список подвыражений в строчном формате, которые были извлечены из строчного/символьного формата S исходного выражения на основе их начальных позиций, определяемых списком n. Список n содержит позиции начала подвыражений в S-строке и/или их префиксы в строчном формате. Тип возвращаемых элементов списка определяется типом первого фактического аргумента вызова процедуры. Процедура обрабатывает основные особые и ошибочные ситуации. Прием, используемый процедурой для извлечения корректных подвыражений, может быть достаточно полезным при программировании других приложений в среде Maple.

Задачи, имеющие дело с поиском минимума и/или максимума (минимакса) выражения имеют не только теоретическое значение для исследования качественных аспектов большого числа математических разделов, но и в большей степени в многочисленных приложениях анализа. Для решения задач данного вида пакет Maple имеет целый ряд инструментальных средств различного уровня. Здесь мы представим aAMV процедуру, до некоторой степени дополняющую стандартные инструментальные средства Maple для поиска минимакса алгебраических выражений, в качестве которых выступают элементы массивов различного типа.

Вызов процедуры aAMV(A) возвращает двухэлементную последовательность вложенных списков. Первый элемент первого списка определяет значение минимального элемента массива А типов {array, Array, Matrix, Vector}, чьи элементы имеют numeric-тип, тогда как остальные его элементы определяют списки координат таких минимальных элементов. Тогда как первый элемент второго списка определяет значение максимального элемента массива A, в то время как остальные его элементы определяют списки координат таких максимальных элементов. Процедура aAMV применима к массивам указанного типа и любой размерности. Данная процедура весьма полезна во многих приложениях.

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

3.10. Элементы отладки Maple-процедур и функций

Проблема отладки может возникать или при появлении рассмотренных выше, или других особых и аварийных ситуаций, либо при получении некорректных с точки зрения решаемой задачи результатов. В настоящее время проблема отладки ПС достаточно хорошо разработана и на данном вопросе нет особого смысла останавливаться. Ибо имеющий определенный компьютерный навык пользователь вполне знаком с данным вопросом. Из простых средств отладки можно отметить методы контрольных точек, трассировки (прокрутки) и др. Maple-язык в качестве такого средства предлагает метод трассировки вычислений, поддерживаемый процедурами {trace, debug}, представляющими на самом деле одну и ту же процедуру, но с альтернативными идентификаторами. Поэтому, говоря о trace-процедуре, будем иметь в виду и альтернативную ей debug-процедуру, и наоборот.

В тестирующем режиме, определенном процедурой {trace|debug}(P1, P2,...,Pn), производится трассировка каждого вызова Рк-процедур/функций, указанных в списке фактических аргументов функции до тех пор, пока не будет {untrace|undebug}(P1, P2, ..., Pn)вызова процедуры соответственно, отменяющего режим тестирования всех либо части тестируемых Pk-процедур/функций. Для трассируемой процедуры/функции на печать выводятся точки их вызова, результаты всех выполняемых промежуточных вычислений и предложений, а также точки выхода. В точках входа указываются фактические значения аргументов, а в выходных – возвращаемые ими результаты. Детально вопросы использования данных средств для отладки процедур рассмотрены в [12], исходную версию книги можно бесплатно получить по адресу [91].

Для отладки механизма вызовов процедур из других процедур весьма полезным средством может оказаться и процедура where(|<Число>), по которой выводится содержимое стэка вызовов процедур на глубину, определяемую значением (целого числа) фактического аргумента функции. Вызов процедуры where() определяет трассировку вызовов процедур, начиная с верхнего уровня; выводятся выполняемые предложения процедур и значения передаваемых процедурам фактических аргументов. При определении глубины стэка выводятся только элементы заданного числа его нижних уровней. С учетом сказанного, вызов where-процедуры должен указываться внутри процедуры, трассировка вызовов которой должна отслеживаться, как это иллюстрирует простой фрагмент трассировки вызовов Kr-процедуры на глубину 5 стэка вызовов процедуры:

Следует отметить, что пакетный отладчик (Debugger) располагает where-командой, аналогичной where-процедуре, за исключением того, что первую можно выполнять интерактивно в отладочном режиме, инициируемом отладчиком. При этом, наибольший эффект от использования where-процедуры можно получить при трассировке рекурсивных вызовов процедур и/или функций. Наряду с процедурами, механизм трассировки на основе where-процедуры можно использовать и для пользовательских функций, как это иллюстрирует пример определения Fnс-функции посредством функционального (->)оператора:

Данный фрагмент использует две процедуры V и Kr, определенные в предыдущем фрагменте, и определяет Fnc-функцию, содержащую вызов where-процедуры, что позволяет использовать для нее описанный механизм тестирования вызовов через стэк.

Встроенный DEBUG-отладчик ориентирован на отладку достаточно сложных процедур в интерактивном режиме и базируется на механизме контрольных точек (check points), допуская два варианта исполнения. По первому варианту режим отладки активируется по функции DEBUG({<Комментарий>}), идентификация Input-параграфа которого производится “DBG>”-метками. Тогда как отмена режима отладки производится по команде {quit|stop|done}, при этом следует иметь в виду, что при вводе команд режима отладки кодирование после них разделителя не допускается. В DEBUG-режиме отладки допускается использование более 16 команд: cont, next, step, into, stopwhen, return, stop, list, where, showstat, showstop, stopat, stoperror и др., обеспечивающих целый ряд важных отладочных функций, с которыми детально можно ознакомиться в книгах [8,9] либо в определенной степени по справке пакета, а также по поставляемой с пакетом документации [78-85]. Там же достаточно детально можно ознакомиться и с ограничениями по применению DEBUG-отладчика. Здесь мы вкратце остановимся лишь на некоторых из наиболее используемых командах режима отладки. Прежде всего, отметим, что кодирование команд DEBUG-режима отладки завершается { |;|:}-разделителем, что отличает их синтаксис от синтаксиса предложений Maple-языка, а также то, что вид разделителя не влияет на возврат результата выполнения команд, как это имеет место в случае традиционных предложений Maple-языка. Новые релизы пакета часто расширяют функции отладчика.

Прежде всего, в целях удобства установки в процедурах контрольных точек рекомендуется пронумеровать составляющие их предложения, что обеспечивает команда отладчика showstat(Proc {, <Диапазон>}), возвращающая определение Proc-процедуры с приписанными ее предложениям номерами, позволяя использовать их при установке контрольных точек. По команде отладчика stopat(Proc {, <{номер|диапазон}> {, <ЛУ>}}) производится установка контрольных точек в предложения Proc-процедуры с номерами, определяемыми ее вторым параметром. При этом, третий необязательный ЛУ-параметр определяет логическое условие, true-значение которого разрешает производить останов в данной контрольной точке. Данное условие может связывать как глобальные, так и локальные переменные, а также и формальные аргументы процедуры. Если предложения процедуры не нумеровались, то производится установка контрольной точки в начало процедуры. По stopat-команде возвращается список всех установленных контрольных точек, а отмена конкретной контрольной точки производится по команде unstopat(Proc, <номер>), тогда как команда unstopat() отменяет все контрольные точки. Расстановка контрольных точек производится в соответствии с логикой отлаживаемой процедуры. В отличие от метода трассировки, метод контрольных точек позволяет исключать из анализа прозрачные участки программ, существенно уменьшая вывод избыточной отладочной информации. В процессе выполнения процедуры производится останов перед предложением, в котором была установлена контрольная точка, позволяя провести отладочные операции. По cont-команде можно продолжить выполнение процедуры до следующей установленной контрольной точки.

По команде stopwhen(<Id>) определяется режим мониторинга значений для указанной ее аргументом локальной или глобальной переменной. В случае глобальной переменной указывается только ее имя, тогда как локальная требует указания в качестве фактического параметра команды списка, первый элемент которого определяет имя процедуры, а второй – имя собственно ее локальной переменной. Отмена мониторинга производится по unstopwhen-команде, относительно которой остается в силе сказанное в адрес команды unstopat. Наконец, по команде stoperror(<Сообщение>) определяется мониторинг появления заданного ее фактическим аргументом диагностического сообщения об ошибках. При возникновении в процессе выполнения процедуры ошибочной ситуации с указанным сообщением (если она не обрабатывается traperror-функцией) активируется режим отладки, выводятся сообщение об ошибке и вызвавшее ее предложение процедуры. По команде showstop() можно получать информацию о всех функциях и процедурах, содержащих предложения stopat, stoperror и stopwhen. Тогда как по функции debugopts предоставляется возможность как проверять, так и модифицировать параметры, управляющие режимом DEBUG-отладки процедур.

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

Не имеет особого смысла установка в процедуре контрольной точки после последнего предложения ее тела: если предложение было отлично от return-предложения, то процедура возвращает NULL-значение, в противном случае – результат выполнения returnпредложения. По stopat-процедуре вообще невозможна установка контрольной точки после последнего предложения процедуры, ибо end-предложение не нумеруется.

При этом, следует иметь в виду, что в DEBUG-отладочном режиме допускается производить вычисления с участием переменных процедуры, выводить промежуточные результаты и присваивать значения переменным процедуры, производя мониторинг вариантов вычислений. Перед выходом из отладочного DEBUG-режима следует отменить установки точек всех типов, т.е. действие stop{at|when|error}-команд, и только после этого выполнить {stop|done|quit}-команду, отменяющую режим отладки с выводом соответствующего сообщения и возвратом в вычислительную среду пакета. В противном же случае производится выход из отладочного режима, но ядро пакета остается в так называемом оперативном DEBUG-режиме, активируемом только в момент вызова соответствующих процедур и функций, определенных указанными командами, которые в этом случае выступают уже на уровне функций языка и требуют соответствующего синтаксиса (должны завершаться {;|:}-разделителем). В оперативном режиме DEBUG допускается использование всех вышерассмотренных команд/функций, тогда как внутри режима отладки определенных ими процедур/функций допускается использование всех команд отладочного режима. Установка контрольных точек любого из рассмотренных трех типов может производиться и внутри самих процедур, инициируя режим отладки в моменты их вызовов, однако, на наш взгляд, это не самая лучшая технология отладки. В [12] и [91] можно найти ряд весьма поучительных примеров применения вышерассмотренных DEBUG-средств языка пакета для отладки достаточно простых процедур.

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

В качестве простого средства отладки Maple-процедур можно использовать и модифицированный метод контрольных точек. Этот метод состоит в следующем. Для генерации процедур, обеспечивающих возвращение значений заданных выражений в установленных контрольных точках, служит процедура ChkPnt [103], кодируемая в самом начале тела тестируемой процедуры Proc в виде вызова ChkPnt(args). Затем в требуемых местах процедуры Proc кодируются вызовы следующего формата:

chkpntN(_x1, _x2, _x3, …, _xn, x1, x2, x3, …, xn)(); (1) chkpntN(_x1, _x2, _x3, …, _xn, x1, x2, x3, …, xn)(x1, x2, x3, …, xn); (2) где N – номер контрольной точки и xj (j=1 .. n) – имена выражений, значения которых требуется получить в данной точке процедуры.

Вызов тестируемой процедуры Proc(args) на кортеже ее основных фактических аргументов не включает механизма контрольных точек, тогда как вызов процедуры Proc(args, chkpnt=N) для N из диапазона [1 .. 61] обеспечивает вывод значений требуемых выражений в контрольной точке с номером N (формат 1) либо вывод значений с их возвратом (формат 2), как это наглядно иллюстрирует достаточно прозрачный фрагмент.

> Proc(64.42, 59.47, 39.67, chkpnt = 1);

Warning, in chkpnt1 variables [_x, _y, _z, _a] have the following values

[64.42, 59.47, 39.67, 96.23]

> Proc(64.42, 59.47, 39.67, chkpnt = 3);

Warning, in chkpnt3 variables [_a, _b, _c] have the following values [96.23, 734.8, 1.862]

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

Наконец, по вызову процедуры maplemint(P) производится вывод протокола результатов семантического анализа P-процедуры, включая ее никогда не выполняемые предложения. Следующий простой фрагмент иллюстрирует результат применения процедуры maplemint на примере анализа простой процедуры:

> AGN:= proc(_x) local a,b; a:= 64(x): b:= ln(x + a): a:= `if`(x >= 10, 3(b^2), `G`) end proc: > maplemint(AGN);

This expression may be missing an operator like '*': 64(x)

This expression may be missing an operator like '*': 3(b^2)

These names were used as global names, but were not declared: x, G

These parameters were never used explicitly: _x

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

В заключение настоящей главы кратко остановимся еще на одном вопросе, связанном с оптимизацией процедур. В качестве определенного подспорья здесь может оказаться и процедура maplemint, чей вызов maplemint(Proc) генерирует отчет с семантической информацией по заданной процедуре Proc (активной в текущем сеансе либо находящейся в Maple-библиотеке, логически связанной с главной библиотекой пакета) и выводит коды, которые невыполнимы при вызове процедуры. Вызов maplemint(Proc) генерирует информацию по таким аспектам процедуры Proc как: константы, присваиваемые в качестве значений; декларированные глобальные переменные, начинающиеся с символа '_' (подчеркивания); неиспользуемые декларированные глобальные переменные; используемые, но не декларированные глобальные переменные; неспользуемые декларированные локальные переменные; переменные цикла, повторно используемые во вложенных циклах; недостижимый код; ключевые слова break и/или next, обнаруженные вне цикла; отсутствие знака умножения '*' и др. Несколько детальнее с данным средством можно ознакомиться по конструкции ?maplemint, тогда как с исходным текстом процедуры можно ознакомиться по следующему предложению:

> interface(verboseproc = 3); eval(`maplemint/recurse`);

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

Из приведенного фрагмента можно сделать ряд выводов, а именно: (1) сложные процедуры, как правило, используют средства обработки особых и ошибочных ситуаций, поэтому они не доступны для анализа процедурой maplemint (даже такая примитивная как процедураProc из последнего примера недоступна для maplemint), (2) далеко не всегда результаты семантического анализа соответствуют конкретному алгоритму тестируемой процедуры, например, для формальных аргументов подпроцедур, глобальных переменных, индексов суммирования и т.д., и (3) в ряде случаев выводимая информация не совсем корректна с точки зрения Maple-языка, как это иллюстрирует нижеследующий весьма простой фрагмент:

> P:= proc() assign('libname' = op([libname, "D:/RANS/IAN"])); `+`(args)/nargs end proc:

> maplemint(P);

These names were used as global names, but were not declared:

"C:\\Program Files\\Maple 8/lib",

"c:/program files/maple 8/lib/userlib"

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

Наконец, синтаксический контролер Mint анализирует программу Maple и генерирует сообщение о возможных ошибках в mpl-файле данных с исходным Maple-текстом. Если файл не задан, то для чтения исходного Maple-текста используется стандартный ввод. Анализ завершается по достижении конца текста. Более детально с данным средством синтаксической проверки Maple-программ можно ознакомиться по конструкции ?mint.

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

Действительно, Maple-язык позволяет в интерактивном режиме программировать алгоритм вашей задачи поэтапно, также поэтапно производя отладку полученных документов либо процедур. Он же позволяет относительно несложно производить их постепенную доводку до нужных требований; при этом, сам процесс такого программирования обеспечивает уточнение отдельных составляющих программируемого алгоритма. При этом, отладка всего комплекса сводится к отладке последовательно связанных его составляющих, которая производится одновременно с их программированием. А так как составляющие с учетом весьма крупных (в плане поддерживаемых операций) функциональных средств Maple-языка, как правило, хорошо обозримы, то и процесс их отладки существенно упрощается, а с ним и весь процесс отладки в целом. Именно данная методика и использовалась нами при создании средств нашей Библиотеки [41,103,109]. Опыт ее применения со всей очевидностью доказал ее жизнеспособность и во многих случаях большую эффективность, чем имеющиеся для этих целей стандартные средства отладки. Правда, описанный подход априори предполагает как хорошее знание сути программируемого приложения, так и саму программную среду пакета.

Рассмотрев процедурные объекты Maple-языка, обеспечивающие достаточно высокий уровень модульности программирования в среде пакета, представим теперь новый тип (начиная с 6-го релиза) объектов Maple-языка, не только повышающих уровень модульности разрабатываемых в среде Maple программных средств, но и в определенной мере обеспечивающих объектно-ориентированную технологию программирования в его среде. Такими объектами являются программные модули, представление которых целесообразно предварить небольшим, но полезным экскурсом в недавнее прошлое программирования.

Глава 4. Организация программных модулей в Maple

4.1. Вводная часть

В настоящей главе рассматриваются модульные объекты Maple-языка, предполагая, что читатель в определенной мере имеет представление о работе в среде Maple в пределах, например, книг [9-14] либо подобных им изданий. Все используемые понятия и определения полностью соответствуют вышеупомянутой книге [13]. Акцент сделан на модульных объектах языка, определяющих возможность использования элементов объектноориентированного программирования в среде Maple-языка.

После 50-летнего периода прогресса в развитии инструментального ПО его возможности начали существенно отставать от возможностей аппаратных средств и эта разница увеличивается с каждым годом. Одной из причин такого состояния является то обстоятельство, что ПС создается последовательно строка за строкой, тогда как большинство современных ЭВМ разрабатывается и создается по интегральной технологии, на основе печатных плат и т.д., позволяя использовать уже хорошо апробированные решения большинства компонент ЭВМ. С появлением объектно-ориентированной технологии (ООТ) появилась возможность разработки ПС на основе готовых базовых программных конструкций и компонент [1-3]. Данный подход позволяет создавать ПС из существующих компонент значительно быстрее и дешевле, обеспечивая существенное повышение их надежности, гибкости и мобильности.

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

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

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

Идеология объектно-ориентированного программирования (ООП) восходит к 60-м годам в связи с исследованиями по проблематике искусственного интеллекта. Понятие программных объектов впервые было введено в языке Simula-67, выросшем из Algol-60 и ориентированном на создание ПС, предназначенных для имитации принятия решений в условиях управляемого множества обстоятельств. Однако ООП-идеология не привлекала широкого внимания вплоть до создания в 1970 г. SmallTalk-языка, состоящего исключительно из объектно-ориентированных конструкций и представляющегося нам наиболее развитым языком ООП. Затем данная идеология была адаптирована разработчиками графических интерфейсов и интегрирована в SmallTalk-подобные языки. Позднее она была адаптирована и в гибридные языки, подобные С+, которые явились первой попыткой навести мосты между более процедурными и ООП-языками. При ООП-подходе понятия процедуры и данных, используемые в обычных системах программирования, заменяются понятиями объект и сообщение; объект – это пакет информации вместе с алгоритмом ее обработки, а сообщение – это спецификация условий одной из операций обработки объекта. В отличие от процедуры, которая описывает алгоритм обработки, сообщение только определяет, что хочет выполнить его отправитель, а получатель точно определяет, как это сделать.

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

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

● наследование: определение объекта с последующим использованием его для построения иерархии порожденных объектов с наследованием доступа каждого из порожденных объектов к процедурам и данным своего предка;

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

За более детальной информацией по ООП и средствам поддержки ООТ можно обратиться к книгам [1-3]. Здесь же мы рассмотрим элементы ООТ, поддерживаемые Maple в лице его программных модулей.

Начиная с 6-го релиза, пакет включает средства по обеспечению ряда базовых элементов объектно-ориентированного программирования, которые поддерживаются механизмом программных модулей языка (или в дальнейшем просто программных модулей – ПМ). Данные модули не следует ассоциировать с более широким понятием пакетных модулей, которые употреблялись на протяжении книг [8-12], рассматривающих пятый релиз пакета. Вместе с тем, можно считать, что программные модули при оформлении их в библиотечные структуры составляют подмножество всех пакетных модулей. Таким образом, если пакетные модули можно рассматривать как внешние по отношению к его ядру хранилища определений функциональных (модульных) средств, то механизм программных модулей, в первую очередь, ориентирован на обеспечение определенного уровня объектноориентированного программирования в среде Maple-языка пакета.

Если процедуры позволяют определять последовательность предложений Maple-языка, описывающих некоторый законченный алгоритм (той либо иной степени сложности), в виде единого объекта, к которому впоследствии можно обращаться с передачей ему фактических аргументов, не интересуясь собственно самой реализацией алгоритма, то механизм программных модулей обеспечивает более высокий уровень абстрагирования, позволяя "скрывать" от пользователя уже целые наборы тематически связанных процедур и данных. Относительно Maple-языка ПМ являются новым типом выражений подобно числам, уравнениям, отношениям и процедурам. Тестирование модульных объектов производится функциями typematch, type и процедурой whattype, как иллюстрирует следующий достаточно простой фрагмент:

При этом, четыре последние примера иллюстрируют возможность тестирования не только готового модульного объекта языка, но и его определения. Для этого определение модуля должно указываться невычисленным, в противном случае возвращается false-значение. Данная организация ПМ позволяет использовать их при программировании параметрических алгоритмов, создании пакетных модулей, а также предоставляет возможность использования в Maple-программах Pascal-подобных записей [1] или C+/C-подобных структур [12]. В среде Maple-языка ПМ могут использоваться несколькими способами, из которых следует отметить 4 наиболее широко используемых, а именно: (1) инкапсуляция, (2) создание модулей пакета, (3) моделирование объектов и (4) параметрическое программирование. Детально эти способы с рекомендациями по их применению рассмотрены в книгах [13-14,29-33,41].

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

Пакетные модули (в отличие от ПМ) обеспечивают механизм совместного хранения тематически связанных Maple-процедур. Такие наборы процедур обеспечивают достаточно развитые функциональные средства, ориентированные на конкретные области приложений, например: linalg и LinearAlgebra (линейная алгебра), stats (статистический анализ данных), plots и plottools (графические средства и средства анимации) и др. Большое количество функциональных средств пакета находится именно в его модулях как внутренних, так и внешних. Основной организацией модулей пакета предыдущих релизов являлась табличная структура [12], в которой входами являлись имена процедур, а выходами их определения. ПМ обеспечивают иной механизм организации модулей пакета, который детально рассмотрен в [13,41]. В частности, пакетный модуль LinearAlgebra, обеспечивающий функции линейной алгебры, был имплантирован в среду пакета релизов 6 и выше именно как программный модуль.

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

4.2. Организация программных модулей Maple-языка

Организация программного модуля (ПМ) весьма напоминает организацию Maple-процедуры, довольно детально рассмотренной в предыдущей главе. В общем случае организация (структура) программного модуля имеет следующий весьма прозрачный вид: module()

export {экспортируемые переменные} local {локальные переменные} global {глобальные переменные} options {опции модуля} description {описание модуля}

Т Е Л О М О Д У Л Я

end module {:|;}

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

Программный модуль является типом Maple-выражения, которое создается в процессе вычисления определения модуля. Данное определение создается программой синтаксического анализа языка на основе представленной выше структуры модуля. Подобно процедуре определение ПМ может включать ряд необязательных деклараций типа global, local, option и description, имеющих тот же смысл, что и в случае процедуры (при этом, специальные опции могут различаться). ПМ можно представлять себе как собрание тематически связанных переменных. При этом, некоторые из этих переменных доступны для текущего сеанса вне определения модуля после его вычисления. Такие переменные задаются в определении модуля как глобальные (global) или экспортируемые (export). Другие переменные определяются явно (local) или неявно локальными и доступны только в рамках определения модуля в период его реализации. Они используются только алгоритмом, реализуемым предложениями Maple-языка, составляющими тело модуля. Переменные такого типа рекомендуется определять явно посредством local-декларации, иначе это сделает сам Maple-язык на основе принятых неявных правил синтаксического и семантического анализа. Все другие переменные, встречающиеся в определении модуля, относятся к глобальным, параметрам либо к локальным в зависимости от возможных приложений. Глобальные переменные могут быть определены глобальными явно через global-декларации модуля или через неявные правила синтаксического и семантического анализа пакета в период упрощения определения модуля. При этом, следует иметь в виду, что множества глобальных, локальных и экспортируемых переменных модуля не должны попарно пересекаться.

Каждый ПМ имеет тело, которое может быть пустым либо содержать Maple-предложения и/или допустимые Maple-выражения. Данные конструкции тела обеспечивают как необходимые вычисления в процессе реализации модуля, так и определяют начальные значения для его экспортируемых переменных. Множество переменных тела модуля и их соотношений составляет полный лексический набор модуля. Это полностью аналогично определению тела процедуры; в обоих случаях используются одни и те же лексические и неявные правила синтаксического и семантического анализа. При этом, в определении модуля и процедуры допускается широкий произвол в их взаимной вложенности (вложенности типов процедура-процедура, процедура-модуль, модуль-процедура, модуль-модуль). Модуль, содержащийся в другом модуле, называется подмодулем относительно второго. Переменным модуля (локальным, глобальным или экспортируемым) могут присваиваться любые допустимые Maple-выражения, включая процедуры и модули. Простейший модульный объект имеет следующий вид: module() ... end module. Данный модуль не имеет особого смысла, т.к. не экспортирует переменных, не имеет ни локальных, ни глобальных переменных, ни даже тела, производящего какие-либо вычисления. В общем случае ПМ можно рассматривать как результат вызова процедуры, которая возвращает некоторые из своих локальных переменных, определенных в модуле как экспортируемые переменные (или экспорты).

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

(1) присвоением определения модуля некоторой переменной; (2) указывая имя между ключевым словом module и "()"-скобками.

Однако, между обоими способами существуют серьезные различия. Поименованный первым способом модуль может многократно переименовываться, создавая свои копии. Тогда как поименованный вторым способом модуль не может быть переименован, а его имя имеет атрибут protected. Если при выполнении поименованного первым способом модуля возникает ошибочная ситуация, то имя модуля идентифицируется как неизвестное (unknown), тогда как для второго случая ошибка привязывается к имени модуля. Это достаточно разумное решение, т.к. модули могут быть непоименованными либо иметь разноименные копии, тогда как второй способ именования делает модуль с фиксированным именем. Следующий простой фрагмент иллюстрирует вышесказанное:

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

Ряд неудобств работы с программными модулями второго типа, которые в ряде случаев требуют более сложных алгоритмов их обработки при создании программного обеспечения с их использованием, поднимает задачу создания процедуры, конвертирующей их в модули первого типа. При этом, под программным модулем первого типа мы будем понимать модуль, именованный конструкцией вида “Name := module () … “, тогда как программный модуль второго типа характеризуется именующей конструкцией следующего вида “module Name () … “. Более того, имеется и третий способ именования программных модулей, позволяющий за одно определение задавать функционально эквивалентные разноименные модули второго типа, как это иллюстрирует следующий весьма простой фрагмент:

> M:= module M1 () export x; x:= () -> `+`(args)/nargs end module: 5*M:- x(64,59,39,17,10);

189

> map(type, [M, M1], `module`), map(type, [M, M1], 'mod1'); ⇒ [true, true], [false, false] > map(mod21, [M, M1]), map(type, [M, M1], 'mod1'), M:- x(59, 39), 3*M1:- x(64, 17, 10); [], [true, true], 49, 91

Некоторые полезные соображения по использованию программных модулей второго типа могут быть найдены в наших книгах [12-14,29-33,39,41,45,103]. Достаточно полезная процедура mod21 решает данную проблему конвертирования программных модулей. Ранее мы уже представляли ее аналог, реализованный нашим методом “дисковых транзитов”, здесь же была использована упоминаемая выше конструкция типа eval({parse|came}(<сгенерированная строка>)).

Вызов процедуры mod21(M) возвращает NULL-значение, т.е. ничего, обеспечивая в текущем сеансе конвертацию программного модуля второго типа, заданного фактическим аргументом M, в эквивалентный ему программный модуль первого типа с тем же самым именем. Если же вызов процедуры mod21(M,f) использует второй необязательный аргумент f, то процедура рассматривает его как каталог, в котором должен быть сохранен файл "M.mod1" с определением отконвертированного программного модуля М (если каталог f отсутствует, то он будет создан с произвольным уровнем вложенности). В этом случае вызов процедуры mod21 возвращает полный путь к файлу данных с сохраненным отконвертированным модулем М и с выводом соответствующего сообщения, информирующем о полном пути к созданному файлу. Файл с сохраненным программным модулем имеет входной Maple-формат. Примеры нижеследующего фрагмента достаточно прозрачно иллюстрируют сказанное.

A2:=module () local C; export R; R:= C[y](1,2,3)+C[z]: module C () local H; export y, z; y:=() -> sum(args[k], k=1..nargs); z:=H[h](6, 7, 8); H:= module () export h; h:= () -> `*`(args) end module end module; end module: A3:= module A3 () export h; h:= () -> sum(args[k], k=1 .. nargs)/nargs end module:

Error, attempting to assign to `A3` which is protected

> M:= module M1 () export G; G:= () -> sum(args[k], k=1 .. nargs)/nargs end module: N:=module N1 () export Z; local M; Z:= () -> M:- h(args); M:= module () export h; h:= () -> sum(args[k], k=1 .. nargs)/nargs end module end module: mod21(A, "C:/temp/aaa/ccc"), mod21(A1,"C:/temp/aaa/ccc"), mod21(A2,"C:/temp/aaa/ccc"), mod21(A3,"C:/temp/aaa/ccc"), mod21(M,"C:/temp/aaa/ccc"), mod21(M1,"C:/temp/aaa/ccc"), mod21(N1,"C:/temp/aaa/ccc"), mod21(N, "C:/temp/aaa/ccc");

Warning, module <A> has been converted into the first type, and saved in datafile

<c:\temp\aaa\ccc\A.mod1>

"C:/temp/aaa/ccc\A1.mod1", "C:/temp/aaa/ccc\A2.mod1", "C:/temp/aaa/ccc\A3.mod1",

"C:/temp/aaa/ccc\M.mod1", "C:/temp/aaa/ccc\M1.mod1", "C:/temp/aaa/ccc\N1.mod1",

"C:/temp/aaa/ccc\N.mod1"

> map(type, [A, A1, A2, A3, M, M1, N, N1], 'mod1');

[true, true, true, true, true, true, true, true]

Следует отметить, что именно на данной процедуре мы обнаружили недостатки работы пакетного стэка и нам пришлось редактировать соответствующим образом процедуру, чтобы обеспечить совместимость в рамках Maple релизов 6-10. Вопросы работы с модулями обоих типов, а также соответствующие для этого средства рассмотрены в наших книгах [12-14,41,42,45,103].

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

Из приведенного фрагмента следует, что тело GRSU-модуля скрыто от пользователя, тогда как описание характеризует его экспортируемую Sr-переменную.

Декларация options . Определение программного модуля может содержать подобно случая процедуры опции, определяющие режим работы с модулем. Однако, в отличие от процедур опции remember, system, arrow, operator и inline не имеют смысла. Опции кодируются или в форме переменной, или уравнения с переменной в качестве его левой части. Если в options-декларации указаны нераспознаваемые языком опции, то они игнорируются, что позволяет пользователю указывать опции для собственных нужд, которые распознаются языком как атрибуты.

Из опций модуль допускает trace, package и `Copyright …`, аналогичные случаю Mapleпроцедур [12], и специальные опции load = name и unload= name, где name – имя локальной или экспортируемой переменной модуля, определяющей процедуру. Данная процедура вызывается при первоначальном создании модуля или при чтении его из системы хранения функциональных средств пакета. Как правило, данная опция используется для какой-либо инициализационной цели модуля. Следующий простой фрагмент иллюстрирует применение load-опции для инициализации Sr-процедуры:

Опция load позволяет создавать наборы тематически связанных экспортируемых процедур, для инициализации которых используются необходимые локальные неэкспортируемые процедуры и/или функции Данная опция выполняет своего рода инициализационные функции модуля. Опция unload = name определяет имя локальной либо экспортируемой процедуры модуля, которую следует вызвать, когда модуль более недоступен либо производится выход из пакета. Модули с опцией `package` понимаются системой как пакетные модули и их экспорты автоматически получают protected-атрибут. Более детально с опциями модуля можно ознакомиться в справке пакета по ?module,option.

Локальные и глобальные переменные ПМ . Аналогично процедурам, ПМ поддерживают механизм локальных (local) и глобальных (global) переменных, используемых в определении модуля. Глобальные переменные имеют областью определения текущий сеанс, тогда как область определения локальных переменных ограничивается самим модулем. Однако, в отличие от процедур, модуль поддерживает более гибкий механизм локальных переменных; при этом, недопустимо определение одной и той же переменной как в local-декларации, так и в export-декларации. Попытка подобного рода приводит к ошибочной ситуации. Результатом вычисления определения модуля является модуль, к экспортируемым членам (переменным) которого можно программно обращаться вне области модуля. Следующий простой фрагмент иллюстрирует результат определения локальных и глобальных переменных программного модуля:

> module() local a,b; global c; assign(a=64, b=59); c:= proc() `+`(args) end proc end module:

> a, b, c(42, 47, 89, 96, 67, 62); ⇒ a, b, 403

> N:= module() export d; d:= proc() `+`(args) end proc end module:

> d(64, 59, 39, 44, 10, 17), N: -d(64, 59, 39, 44, 10, 17); ⇒ d(64, 59, 39, 44, 10, 17), 233

> module() local a,b; export a,b,c; assign(a=64, b=59); c:=proc() nargs end proc end module; Error, export and local `a` have the same name

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

<Имя модуля>:- <Экспортируемая переменная>{(Фактические аргументы)}

<Имя модуля>[ <Экспортируемая переменная>]{(Фактические аргументы)} Это так называемый связывающий формат обращения к экспортируемым переменным модуля. По вызову встроенной функции exports(M) возвращается последовательность всех экспортов модуля М, тогда как по вызову процедуры with(M) возвращается список всех экспортов модуля М; при этом, во втором случае экспорты модуля М становятся доступными в текущем сеансе и к ним можно обращаться без ссылок на содержащий их модуль, как это иллюстрирует следующий простой фрагмент:

Фрагмент представляет модуль М с двумя экспортами Dis и Sr. По вызову exports(M) получаем последовательность всех экспортов модуля М, однако это только имена. Затем по (:-)-связке получаем доступ к экспорту Dis с передачей ему фактических аргументов. Наконец, по вызову with(M) получаем список всех экспортов модуля М, определяя их доступными в текущем сеансе. Таким образом, глобальность той или иной переменной модуля можно определять или через global-декларацию, или через export-декларацию модуля. Однако, если в первом случае мы к такой переменной можем обращаться непосредственно после вычисления определения модуля, то во втором случае мы должны использовать (:-)-связку или вызов формата M[<Экспорт>]{(Аргументы)}. Наконец, модуль V и процедура V1 иллюстрируют функциональную эквивалентность обоих объектов – модульного и процедурного с тем лишь отличием, что модуль V позволяет «скрывать» свое тело в отличие от V1-процедуры. Таким образом, можно создавать модули без экспортов, возвраты которых обеспечиваются через их глобальные переменные, что обеспечивает скрытие внутреннего механизма вычислений. Однако, при сохранении такого модуля в Maple-библиотеке (пакетной или пользовательской) последующий доступ к его глобальным переменным стандартными средствами становится невозможным, т. е. указанный прием работает лишь при условии вычисления определения модуля в текущем сеансе. Следовательно, описанный выше прием достаточно искусственен и ограничен, и носит в основе своей лишь иллюстративный характер.

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

M:= module() end module или module M1 () end module о чем говорит и их тестирование, а именно:

> restart; M:= module() end module: module M1 () end module:

> map(type, [M, M1], `module`), map(whattype, map(eval, [M, M1]));

[true, true], [module, module]

Тогда как попытка получить их экспорты посредством вызова with-процедуры вызывает ошибочную ситуацию со следующей релизо-зависимой диагностикой:

Тогда как во всех релизах переменная lasterror получает идентичное значение. Поэтому для обеспечения более простой работы с программными модулями рекомендуется для получения их экспортов использовать встроенную функцию exports, как иллюстрирует последний пример фрагмента, либо использовать нашу процедуру [103], которая является расширением стандартной процедуры with и которая не только в данной ситуации возвращает корректный результат, но и позволяет использовать себя внутри процедур в отличие от with, например:

Это обстоятельство следует учитывать при работе с модулями в программном режиме.

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

Декларация export определяет последовательность локальных имен объектов модуля, к которым возможен доступ извне модуля, т.е. определяет локальные переменные (присущие сугубо модулю и скрываемые от внешней среды) глобальными. В отличие от локальных экспортируемые переменные модуля не могут быть определены таковыми неявно. Их следует определять явно через export-декларацию. Важно помнить, что при экспортировании модулем неопределенной локальной переменной она не тождественна одноименной глобальной переменной текущего сеанса, что иллюстрирует следующий пример:

> module R() export VG; VG:= () -> `+`(args) end module: evalb(VG= R:- VG); ⇒ false > VG:= 64: VG, R:- VG(64, 59, 39, 10, 17); ⇒ 64, 189

Из примера видно, что экспортируемая неопределенная переменная не тождественна одноименной глобальной VG-переменной. Данное свойство модульного механизма языка пакета позволяет, в частности, определять в модуле одноименные с пакетными функциональные средства, но определяющие различные вычислительные алгоритмы, как это иллюстрирует следующий простой фрагмент (см. прилож. 6 [13]):

> GU:=module() local k; export ln; ln:=()->evalf(sum(log(args[k]),k=1..nargs)) end module:

> ln(42, 47, 67, 89, 96, 64);

Error, (in ln) expecting 1 argument, got 6

> GU[ln](42, 47, 67, 89, 96, 64); ⇒ 25.00437748

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

Вне программного модуля обращение к экспортируемым переменным модуля производится по конструкциям следующего общего вида:

Имя_модуля:- Имя_экспортируемой_переменной{(Аргументы)}

Имя_модуля[Имя_экспортируемой_переменной]{(Аргументы)}

Более того, выполнение предложения with(Имя_модуля) позволяет обращаться ко всем экспортируемым переменным модуля только по их именам, делая их доступными в текущем сеансе для любого активного либо находящегося в очереди готовых документов, как это иллюстрирует следующий весьма простой фрагмент:

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

Каждое определение Maple-процедуры ассоциируется с неявными переменными args, nargs и procname, рассмотренными выше. Тогда как с определением ПМ ассоциируется только одна неявная thismodule-переменная. В рамках тела модуля данной переменной присваивается содержащий ее модуль. Это позволяет ссылаться на модуль в рамках его собственного определения. Следующий простой фрагмент иллюстрирует применение переменной thismodule:

> module AVGSv() export a, b; a:= () -> sum(args[k], k=1..nargs); b:= thismodule:- a(42, 47,

67, 62, 89, 96) end module: AVGSv:- a(64, 59, 39, 44, 17, 10), AVGSv:- b; ⇒ 233, 403 Посредством thismodule-переменной предоставляется возможность организации рекурсивных выполнений модуля внутри самого модуля, что существенно расширяет возможности модульного программирования в среде Maple-языка пакета.

По функции op можно получать доступ к трем компонентам модуля М, а именно:

1) op(1, eval(M)) – последовательность экспортов модуля М

2) op(2, eval(M)) – оболочка определения модуля М

3) op(3, eval(M)) – последовательность локальных переменных модуля М Приведем пример на применение функции op относительно простого модуля:

> M:=module() local a,b; export x; a, b:= 64, 59; x:= (y) -> a*y+b*y end module:

> [op(1, eval(M))], op(2, eval(M)), [op(3, eval(M))];

[x], module() local a, b; export x; end module, [a, b]

Следует отметить, что по вызову op(2, eval(M)) возвращается не исходное определение модуля, а скорее его упрощенная копия (оболочка определения модуля) без самого тела. Она используется только для качественной печати модуля.

Дополнительно к ранее рассмотренным, для модулей в релизе 10 введен ряд дополнительных переменных, а именно. Если модуль М экспортирует переменную ModuleApply, то вызов вида M(args) обеспечивает вызов процедуры M:-ModuleApply(args), например:

> M:=module() export ModuleApply; ModuleApply:=()->evalf(`+`(args)/nargs) end module: > M(64, 59, 39, 17, 10, 44); ⇒ 38.8333333300

Если модуль содержит локальную либо экспортируемую переменную ModuleLoad, то определенная ею процедура вызывается, когда модуль читается из содержащей его Mapleбиблиотеки. Если модуль имеет локальную либо экспортируемую ModuleUnload-переменную, то определенная ею процедура вызывается, когда модуль больше недоступен или в случае завершения сеанса с Maple. Две последние переменные являются зеркальными средствами опций load и unload модуля. Если модуль имеет локальную или экспортируемую ModulePrint-переменную, то вместо модуля возвращается результат вызова ModulePrint(). Более детально с данными переменными модуля можно ознакомиться в справочной системе Maple по запросу ?module. Как следует из их описания, данные переменные ничего особо существенного не несут, однако в ряде случаев могут оказаться достаточно полезными.

Механизм вызовов Maple не позволяет использовать динамически генерируемые имена для экспортов модуля. Данную задачу решает процедура dcemod [41,103,109].

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

Proc:= proc(Параметры {::Типы})

Module() export {Переменные};

<ТЕЛО модуля, содержащее Параметры>

end module end proc;

Параметризация позволяет создавать модули, легко настраиваемые на конкретные условия применения, что обеспечивает их гибкость и мобильность при программировании задач из различных приложений. Вышеприведенный простой фрагмент иллюстрирует применение данной конструкции для параметризации конкретного программного модуля, определенного в процедуре SveGal. Процедура SveGal в качестве формальных аргументов a и b использует параметры вложенного в нее модуля, экспортирующего две функции Gal и Sv. Присвоение вызова данной процедуры с конкретными фактическими аргументами некоторой переменной генерирует поименованный первым способом программный модуль, параметры a и b которого получают конкретные значения. Следовательно, мы получаем программный модуль, настроенный на определенные значения его параметров. В дальнейшем такой модуль используется описанным выше способом. Описанный механизм позволяет производить параметризацию программных модулей, что обеспечивает решение разнообразных задач параметрического программирования в среде пакета Maple.

Представленные в книге [103] процедуры нашей Библиотеки представляют целый ряд весьма полезных средств для работы с программными и пакетными модулями, существенно дополняющими имеющиеся стандартные средства пакета. Вместе с тем, данные средства позволяют детализировать сами модульные Maple-объекты и использовать их особенности для программирования задач с использованием подобных объектов. Так, в главе 3 [41] представлена группа средств, расширяющих возможности пакета Maple релизов 6 – 10 при работе с процедурами и программными модулями. Данные средства поддерживают такие виды обработки как преобразование модулей в процедуры, проверка наличия в файлах некорректных модулей, проверка аргументов процедур и модулей, проверка активности (пригодности к непосредственному использованию) процедуры или модуля, проверка типа модульной таблицы, преобразование файлов входного формата Maple, содержащего модули, преобразование модуля второго типа в первый тип, преобразование файла входного формата Maple в файл внутреннего формата Maple, и наоборот, и т.д. Представленные инструментальные средства обеспечивают набор разнообразных полезных операций с процедурными и модульными объектами Maple. Эти инструментальные средства используются достаточно широко при расширенном программировании различных приложений в Maple и в целом ряде случаев весьма существенно упрощают программирование.

4.3. Сохранение процедур и модулей в файлах

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

save N1, N2, ..., Nk, <Файл> или save(N1, N2, ..., Nk, <Файл>)

где N1, N2, ..., Nk – последовательность имен сохраняемых объектов и Файл – имя файла или полный путь к нему типа {string, symbol}. Объекты Maple-языка сохраняются в файлах в одном из двух форматов (входном Maple-формате, в терминах DOS эквивалентном формату ASCII, и внутреннем m-формате). Вызов save(N1, N2, ..., Nk, <Файл>) либо выполнение предложения save N1, N2, ..., Nk, <Файл> пишет в заданный файл определения имен N1, N2, ..., Nk в виде последовательности предложений присвоения. При попытке сохранения неопределенного имени А в файл пишется предложение A:= A. Успешный вызов save(…) возвращает NULL-значение, т.е. ничего.

При этом, если в файле определено m-расширение имени, то файл сохраняется во внутреннем m-формате пакета, в противном случае используется входной формат Maple-языка, т. е. (ASCII-формат). Внутренний m-формат используется, чтобы сохранять процедуры, модули и другие объекты в более компактном, простом для чтения пакетом формате. Объекты, сохраненные во внутреннем формате, могут читаться быстрее (прежде всего, при файлах большого объема) чем объекты, сохраненные во входном Maple-формате языка. Следующий весьма простой пример иллюстрирует сохранение целочисленного L-списка из 1000 элементов в файлах обоих форматов, из которого следует, что файл “file” входного формата занимает 5024 байта, тогда как файл “file.m” внутреннего формата только 4026 байтов.

> L:= [k$k=1 .. 1000]: save(L, “C:\\temp\\file”); save(L, “C:\\temp\\file.m”);

При этом, для больших сохраняемых объектов эта разница может быть довольно существенной. В случае указания в save-предложении неопределенных Id-идентификаторов, они сохраняются в виде Id := 'Id' с выводом соответствующих предупреждающих сообщений, например:

> save(h, g, s, `D:\\Academy\\file`);

Warning, unassigned variable `h` in save statement

Warning, unassigned variable `g` in save statement

Warning, unassigned variable `s` in save statement

Именно внутренний m-формат (m-файлы) представляют Maple-объекты, сохраняемые в библиотеках пакета (т.н. Maple-библиотеках) и идентичных с ними по организации. Однако, здесь имеется и одно существенное «но». Файлы с Maple-объектами, сохраненными во входном Maple-формате посредством предложения save, мобильны относительно всех релизов пакета (хотя они и могут быть синтаксически зависимы от релиза), тогда как файлы внутреннего m-формата всегда релизо-зависимы. Попытка чтения m-файла (не соответствующего текущему релизу) посредством предложения read вызывает ошибочную ситуацию, тогда как чтение файла во входном Maple-формате корректно в любом релизе, если определения процедур и модулей, расположенных в нем, не содержат каких-либо релизо-зависимых синтаксических элементов. В нынешних реалиях m-файлы, созданные в среде пакета Maple 6, несовместимы с m-файлами, созданными в среде релизов 7 – 10, тогда как в рамках релизов 7 – 10 имеет место полная совместимость. Обусловлено это изменением соответствия между идентификационными номерами внутренних структур данных и их именами. В дальнейшем мы будем называть файлы, корректно читаемые предложением read, файлами пакета или Maple-файлами.

Следующий простой фрагмент иллюстрирует применение save-предложения для создания файлов обоих указанных форматов (входного и внутреннего):

> Sr:= () -> `+`(args)/nargs: save(Sr, "C:/Temp/Sr"); save(Sr, "C:/Temp/Sr.m");

Sr := proc () options operator, arrow; `+`(args)/nargs end proc; - входной формат

M7R0 - m-формат

I#Srf*6”F$6$%)operatorG%&arrowGF$*&-%”+G6#9”“““9#!”“F$F$F$F$

В данном фрагменте определяется простая Sr-процедура и по save-предложению сохраняется в Sr-файлах во входном ("Sr") и внутреннем ("Sr.m") форматах. Содержимое обеих файлов выводится. На небольшого объема файлах не ощущается преимущества от того либо иного формата, однако при возрастании объема предпочтение внутреннего m-формата становится все ощутимее, позволяя создавать более компактные и быстрочитаемые пакетом файлы данных.

Загрузка сохраненного по save-предложению файла данных выполняется по предложению read, которое имеет следующие простые форматы кодирования: read <Файл> или read(<Файл>)

где Файл – имя файла или полный путь к нему типа {string, symbol}; при этом, если файл указывается только именем, а не полным путем к нему, то предполагается, что он находится в текущем каталоге. Между тем, результат save-предложения зависит от формата загружаемого файла. Общим является тот факт, что после загрузки файла содержащиеся в нем определения становятся доступными в текущем сеансе, если впоследствии не определяется противного. Между тем, если загружается файл входного Maple-формата, то в случае завершения read-предложения (;)-разделителем на монитор выводится содержимое файла, а вызов read-предложения возвращает значение последнего его предложения. Тогда как по (:)-разделителю информации не выводится, но также возвращается значение последнего предложения загруженного файла. В случае загрузки m-файла информации не выводится и возвращается NULL-значение. Примеры следующего фрагмента иллюстрируют применение read-предложения для загрузки файлов данных обоих форматов (входного и внутреннего):

На первых порах работы с Maple-языком средства доступа к внутренним m-файлам наиболее полезны при необходимости создания различного рода библиотек пользовательских процедур или функций, а также сохранения часто используемых Maple-конструкций. Независимо от формата (m-формат либо ASCII-формат) сохраненного по предложению save файла последующая его загрузка по read-предложению вызывает вычисление всех входящих в него определений (если до выгрузки они были вычисленными), делая их доступными в текущем сеансе работы с пакетом.

В Maple 6 save-предложение допускает формат save(F), по которому пишет все вычисленные в текущем сеансе имена в файл F как последовательность предложений присвоения. Кроме того, данная возможность предоставляется только для F-файлов данных, чьи имена завершаются ".m", т.е. файлы внутреннего Maple-формата. Однако, начиная с Maple 7, такая возможность отсутствует. Между тем, в ряде случаев подобное средство может упростить программирование и облегчить работу с Maple. В этом плане может оказаться достаточно полезной наша процедура saveall [41-43,103,108,109].

Вызов процедуры saveall(F) возвращает реальный путь к принимающему файлу данных

(имя которого либо путь к нему определены фактическим аргументом F), содержащему все вычисленные в текущем сеансе имена в виде последовательности предложений присвоения. При этом, процедура не сохраняет встроенные средства, переменные среды пакета, пакетные модули, библиотечные средства в рамках всех библиотек, определенных предопределенной libname-переменной Maple. При отсутствии сохраненных имен вызов процедуры возвращает NULL-значение, т. е. ничего, с выводом соответствующего сообщения, как это иллюстрирует предыдущий фрагмент. В целом ряде случаев saveallпроцедура имеет достаточно полезные приложения.

Еще на одном весьма существенном аспекте следует заострить внимание. Предложение save некорректно сохраняет программные модули, например:

Из приведенного фрагмента видно, что сохраненные по save-предложению в m-файле модули M, M1 и M2, затем читаются read-предложением в текущий сеанс и распознаются type-функцией действительно как модули. Более того, вызов with-процедуры вполне корректно возвращает списки экспортируемых модулями переменных. Тогда как стандартные вызовы этих переменных возвращаются невычисленными, т.е. экспортируемые такими модулями переменные оказываются неопределенными. Причина лежит в том, что save-предложение не сохраняет в m-файлах внутреннего Maple-формата тела программных модулей.

Весьма детальное обсуждение данного вопроса может быть найдено в наших книгах [29-33,39,42-44,103]. Для устранения подобного недостатка нами был предложен ряд интересных средств, существенно расширяющих функциональные возможности стандартных предложений save и read, с которыми можно ознакомиться в нашей книге [103] и в прилагаемой к ней Библиотеке. В частности, предложение save не позволяет сохранять в файле динамически вычисляемые имена, что в целом ряде случаев представляется существенным недостатком. Наша процедура save1 [103] устраняет данный недостаток.

Вызов процедуры save1(N, E, F) пишет указанные переменные, определенные фактическим аргументом N, в файл, указанный фактическим аргументом F, как последовательность предложений присвоения. Если некоторому элементу n из N не присваивалось значения, то в файл записывается предложение присвоения n := n с выводом соответствующего сообщения. Если некоторый элемент n из N защищен (имеет protected-атрибут), то элемент игнорируется с выводом соответствующего сообщения. Более того, если все элементы из N защищены, то инициируется ошибочная ситуация. Успешный вызов процедуры save1 возвращает полный путь к файлу данных F, обеспечивающему присвоения выражений E соответствующим символам из N в текущем сеансе Maple с выводом необходимых сообщений.

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

Приведем еще пару процедур, расширяющих предложения save и read по работе с программными модулями пакета. Обе процедуры savem1 и readm1 имеют форматы кодирования следующего вида:

savem1(F, M) и readm1(R)

соответственно, где F – имя или полный путь к файлу внутреннего Maple-формата (mфайлу) и М – программный модуль первого типа или их последовательность. При этом, модули не должны иметь protected-атрибута. Процедура savem1 предназначена для сохранения программных модулей первого типа в файлах внутреннего Maple-формата (mфайлах); если в качестве F-аргумента указан не m-файл, то к его имени добавляется расширение “.m”. Успешный вызов процедуры возвращает путь к созданному m-файлу с сохраненными в нем модулями M. Тогда как процедура readm1(R) читает в текущий сеанс файл R с корректной активацией сохраненных ранее в нем по savem1-процедуре программных модулей. Успешный вызов процедуры возвращает NULL-значение, т.е. ничего. Ниже представлен фрагмент с исходными текстами обеих процедур и примерами их применения для сохранения/чтения программных модулей первого типа.

Обе процедуры обрабатывают основные особые и ошибочные ситуации. Алгоритм первой процедуры базируется на строчном представлении определения программного модуля, сохраняемого в специальном формате в файле внутреннего формата. Тогда как вторая процедура использует представление сохраненного в m-файле модуля, используя структуру файлов такого типа и специальную процедуру Iddn1, обеспечивающую возврат имен Maple-объектов, сохраненных в файлах внутреннего Maple-формата. В качестве весьма полезного упражнения читателю рекомендуется рассмотреть организацию обоих процедур.

В ряде случаев возникает необходимость анализировать m-файл внутреннего формата Maple на предмет находящихся в нем объектов. Данную задачу решает mnames-процедура, исходный текст и примеры применения которой приведены ниже. Вызов процедуры mnames(F) для случая анализа в среде Maple 6 файла F, подготовленного в среде Maple 7 - 10, возвращает только множество имен объектов с выводом сообщения.

Тогда как аналогичный вызов mnames(F) для случая анализа в среде Maple 7 - 10, файла F, подготовленного в среде Maple 6 - 10, не только возвращает таблицу, чьими входами являются типы объектов файла, а выходами множества соответствующих им имен, но и делает эти объекты активными в текущем сеансе. Тогда как вызов mnames(F, P) при тех же предположениях, где P – произвольное Maple-выражение, оставляет имена объектов файла F неопределенными, возвращая при этом вышеуказанную таблицу. Процедура неоднократно успешно использовалась для анализа незнакомых файлов внутреннего Maple-формата. Целый ряд других полезных средств для сохранения программных модулей в файлах внутреннего Maple-формата, а также для работы с файлами указанного формата представлен в наших книгах [41,42,103] и в прилагаемой к ним Библиотеке для пакета Maple релизов 6 – 10. Наряду с практическим интересом данные средства представляют определенный интерес и для практического программирования в Maple, предлагая целый ряд полезных и эффективных приемов программирования.

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

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

5.1. Средства работы Maple-языка с выражениями строчного и символьного типов

В настоящей главе рассмотрим базовые средства работы в среде Maple-языка с данными строчного (string) и символьного (symbol) типов более детально. Для тестирования выражений типа string используется уже упоминаемая whattype(S)-процедура, возвращающая string-значение, если результат вычисления S-выражения имеет string-тип. Тестирование можно осуществлять и по type(S, 'string')-функции, возвращающей true-значение в случае S-строки и false в противном случае. Для тестирования выражений типа symbol используется уже упоминаемая whattype(S)-процедура, возвращающая symbolзначение, если результат вычисления S-выражения имеет symbol-тип. Тестирование можно производить и по type(S, 'symbol')-функции, возвращающей true-значение в случае S-символа и false в противном случае. Данные строчного и символьного типов играют весьма важную роль при операциях ввода/вывода, работе с текстовой информацией, символьных вычислениях и преобразованиях и др. При этом, данные этих типов наиболее широко используются, в первую очередь, в задачах символьных обработки и вычислений [8-14,41,78-90,55,58-62,103,108,109].

Символьные значения представляются как простыми идентификаторами, так и составными, ограниченными верхники кавычками (`); при этом, любая цепочка символов, ограниченная кавычками, рассматривается в качестве символьного значения. Тестирующими средствами Maple-языка символьные выражения распознаются как значения типа {symbol, name}, как это иллюстрирует следующий весьма простой пример: > whattype(AV), whattype(`A V Z`), whattype(Academy_Noosphere); symbol, symbol, symbol

> type(AV, 'symbol'), type(`A V`, 'symbol'), type(Academy_Noosphere, 'name'); true, true, true

Строчные выражения представляются значениями, ограниченными двойными кавычками ("); при этом, любая цепочка символов, ограниченная такими кавычками, рассматривается в качестве строчного значения. Тестирующими средствами Maple-языка строчные значения распознаются как значения string-типа, как это иллюстрирует следующий простой пример:

> whattype("AV"), whattype("A V Z"), whattype("Academy"); ⇒ string, string, stringl

> type("AV",'string'), type("A V",'string'), type("Academy_2006", 'string'); ⇒ true, true, true

При этом, со строчной информацией на уровне отдельного символа Maple-язык работает как со строками длины 1, например length("A")=1, что не требует специального определения типа для отдельных символов. В дальнейшем для строчных и символьных выражений будем использовать групповое имя «символьные» выражения. Для конвертации строчных выражений в символьные и наоборот служит convert-функция, как это иллюстрирует следующий простой фрагмент:

> convert("AVZ", 'symbol'), convert(AVZ, 'string'); ⇒ AVZ, "AVZ"

> ``||"AVZ", ""||AVZ, cat(``, "AVZ"), cat("", AVZ); ⇒ AVZ, "AVZ", AVZ, "AVZ"

> cat(a + b, 'string'), ""||(a + b); ⇒ || (a + b) || string, "" || (a + b)

Конвертацию можно проводить и посредством cat-функции и ||-оператора конкатенации, как иллюстрирует второй пример фрагмента. Тогда как последний пример подтверждает, что именно convert-функция является наиболее общим средством подобной конвертации символьно/строчных выражений.

Для обеспечения работы со строчными выражениями Maple-язык располагает рядом базовых средств манипулирования со строками, пригодными, в свою очередь, и для обработки символьных значений. Немногочисленные средства собственно Maple-языка по обеспечению работы с данными указанных двух типов достаточно прозрачны и в том или ином виде имеются во всех современных системах программирования, поэтому особых пояснений не требуют. Отметим лишь средства, наиболее часто используемые в практическом программировании в среде Maple. Их специфические свойства и особенности достаточно детально рассмотрены в [8-14,29,30,41,103,108].

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

cat(S1, S2, ..., Sn) и S1||S2|| ... ||Sn

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

> map(whattype, map2(cat, "TRG", ["IAN", RANS])); ⇒ [string, string]

> map(whattype, map2(cat, TRG, ["IAN", RANS])); ⇒ [symbol, symbol]

> whattype("TRG"||RANS), whattype(TRG||"RANS"); ⇒ string, symbol

При этом, следует отметить, что в качестве первого операнда ||-оператора могут выступать и более общего вида выражения, однако как для cat-функции, так и для оператора конкатенации имеет место ряд особенностей (детально представленных в [12-14,39]), позволяющих рассматривать их, прежде всего, именно как средства работы со строчными данными и структурами. По substring-функции, имеющей простой формат кодирования: substring({"<Строка>"|`<Символ>`}{, m|, m..n})

возвращается соответственно {строка|символ}, находящиеся на m-й позиции заданного первым фактическим аргументом значения {string|symbol}-типа или начинающиеся с m-й и заканчивающиеся n-й позицией. В случае отрицательных значений позиций отсчет производится, начиная с правой границы исходных {строки|символа}. Тогда как вызов length(<Выражение>)-функции возвращает длину результата вычисления выражения и в случае его типа {string| {symbol|name}} – длину {строки|символа}. Для целых числовых значений возвращается число цифр, исключая знак; тогда как для других Maple-выражений по length-функции возвращается результат, определяемый как сумма длин каждого операнда выражения, вычисляемых рекурсивно, и числа слов, используемых для представления исходного выражения. Данный результат определяет своего рода числовую меру сложности выражения. Следующий простой фрагмент иллюстрирует сказанное:

> H:= `Russian Academy of Natural Sciences`: M:= "Tallinn Research Group":

> map(length, [H, M, 42.64, -59, cat(H, M), ``||H||M, sin(x)+y^2]); ⇒ [35,22,8,2,57,57,21]

> cat(substring(H, 9 .. 15),`, `, substring(M, 9 .. length(M))); ⇒ Academy, Research Group

> cat(sin(x), TRU), cat(convert(sin(x), 'string'), TRU); ⇒ || (sin(x)) || TRU, "sin(x)TRU"

Таким образом, если относительно функций cat и length допускаются значения фактических аргументов типов {string, symbol, name} с учетом того, что тип возвращаемого catфункцией результата определяется типом ее первого аргумента, то уже в общем случае ||-оператора конкатенации требуется специальный формат его кодирования. Тогда как последний пример фрагмента хорошо иллюстрирует тот факт, что в общем случае произвольное Maple-выражение, выступающее в качестве аргумента (операнда) cat-функции (||-оператора), предварительно следует конвертировать в строку либо символ.

По функции {searchtext|SearchText}, имеющей следующий формат кодирования:

{searchtext|SearchText}(`<Контекст>`, {"<Строка>"|`<Символ>`}{, m..n}) производится регистро-{независимая|зависимая} идентификация факта вхождения заданного контекста в заданные {строку|символ}. Если закодирован и третий аргумент (позиции), то поиск осуществляется относительно указанного местоположения контекста в {строке|символе}. Сказанное о втором аргументе substring-функции полностью сохраняет силу и для третьего аргумента {searchtext|SearchText}-функции. Обе функции поиска возвращают позицию первого вхождения контекста в строку; нулевое значение говорит об отсутствии в строке искомого контекста. При этом, следует иметь в виду, что возвращаемый по searchtext(Контекст, S, n..p)-вызову номер позиции (m) первого вхождения искомого контекста в S-строку в диапазоне [n..p] отсчитывается не от начала строки, а от n-позиции, как базовой; т.е. относительно начала строки номер позиции определяется как (n+m), что следует учитывать при программировании с использованием данного средства Maple-языка.

При этом, на основе SearchText-функции Maple-язык предоставляет и недокументированную процедуру search(S, s {, 't'}), которая тестирует факт вхождения s-подстроки в S-строку (в качестве s и S могут выступать символы и/или строки), возвращая соответственно true или false. Если при вызове процедуры быд определен и третий необязательный t-аргумент, то через него возвращается позиция первого вхождения s в S; при отсутствии такого вхождения t-аргумент возвращается невычисленным. Следующий простой пример хорошо иллюстрирует вышесказанное:

> searchtext(`_`, Academy_Nooshpere), [search(Academy_Nooshpere, `_`, 'p'), p];

8, [true, 8]

> SearchText(n, Academy_Nooshpere), SearchText(N, Academy_Nooshpere); ⇒ 0, 9

По конструкции вида {\n} можно определять режим переноса строчного выражения на новую строку, кодируя его в нужных местах длинных строчных или символьных выражений, например:

> `Address: \nRaadiku 13 - 75\nTallinn 13817\nEstonia\nwww.aladjev.newmail.ru`;

Address:

Raadiku 13 – 75

Tallinn 13817 Estonia

www.aladjev.newmail.ru

Для обеспечения синтаксического анализа строчной структуры, заключающей в себе Maple-выражение/предложение, служит parse-функция, имеющая форматы: parse({ |"<Строка>"|"<Строка>", <Параметры>})

parse({ |`<Символ>`|`<Символ>`, <Параметры>})

Предполагается, что содержимое аргумента “Строка” определяет одно Maple-выражение либо предложение, если указан statement-параметр в качестве второго аргумента функции. Данная функция производит синтаксический анализ заданной своим первым аргументом строки, как если бы она была введена в Input-параграфе или считана из файла. Выражение/предложение, составляющее строку, анализируется на соответствие синтаксису Maple-языка и возвращается невычисленным. Если же в результате анализа обнаружена ошибка, то выводится сообщение вида: “Error, incorrect syntax in parse: <Тип ошибки> (m)”, где m-число определяет позицию строки, с которой ассоциируется обнаруженная ошибка указанного типа. Данное сообщение возможно использовать для обработки ошибочных и особых ситуаций. Даже в случая обнаружения parse-ошибки по (%)конструкции возвращается значение строки невычисленным. В случае второго формата parse-функции сохраняет силу все сказанное относительно ее первого формата, т.е. функция обрабатывает значения как string, так и symbol-типа.

Если содержимое строки – Maple-предложения не завершается {;|:}-разделителем либо символом перевода строки (СПС), то автоматически устанавливается (;)-разделитель, если не определен nonsemicolon-параметр. С другой стороны, если содержимое строки завершается {;|:}-разделителем, но не содержит СПС, то он добавляется автоматически. Наконец, по вызову функции parse() возвращается {true|false}-значение в зависимости соответственно от того, завершалось ли содержимое последней успешно обработанной parseфункцией строки (;)-разделителем либо нет. Следующий фрагмент иллюстрирует разные варианты вызова parse-функции:

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

> AGN:= "(x^3 + 5.9*sin(x)/(exp(10*x) - Kr*Pi*sqrt(gamma/x))": length(AGN); ⇒ 51 > parse(AGN, 'statement');

Error, incorrect syntax in parse: `;` unexpected (53)

В данном фрагменте parse-функция диагностирует отсутствие (;)-разделителя в несуществующей позиции AGN-строки {length(AGN)=51}. Более того, такая ситуация должна автоматически обрабатываться parse-функцией, как отмечено выше. Тогда как в данном случае имеет место несоответствие числа открывающих и закрывающих скобок выражения/предложения Maple, составляющего AGN-строку. Во многих случаях значение m-параметра диагностического сообщения parse-функции весьма приблизительно идентифицирует место ошибки (как правило, с точностью до операнда).

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

В зависимости от х-значения А-процедура возвращает одну из процедур (активную в текущем сеансе) с именем, определенным вторым фактическим y-аргументом. Тогда как Fпроцедура, базирующаяся на parse-функции и реализованная однострочным экстракодом, возвращает n-арную процедуру (активную в текущем сеансе) с заданным именем f и ведущими переменными, начинающимися с x. В общем случае пусть Р – исходная конструкция, подлежащая созданию/модификации с последующим ее вычислением (активизацией) в текущем сеансе. На первом этапе обеспечивается вызов следующего формата: P1:= convert({P|eval(P)}, 'string')

После этого, согласно требуемому алгоритму модификации строка P1 обрабатывается средствами, ориентированными на обработку строк, включая и эффективные процедуры, представленные нашей библиотекой [103,109], давая в результате P2-строку. И на заключительном этапе по вызову eval(parse(P2)) получаем результат вычисления P2-выражения, доступный в текущем сеансе. Нижеприведенный текст процедуры Aproc [109], генерирующей расширенные процедуры, весьма прозрачен и превосходно иллюстрирует описанный выше механизм герерации выражений посредством parse-функции:

Для возможности представления конструкций в P1-строке можно эффективно импользовать для их программирования такие средства как assign, assign67, seq, add и целый ряд других. Достаточно эффективным средством выступает использование непоименованных процедур. В частности, посредством этих средств мы имеем возможность программировать однострочные экстракоды, реализующие достаточно сложные алгоритмы. Немало примеров этому можно найти в книге [41,103]. Сложность таких конструкций определяется как опытом, так и навыками пользователя. Между тем, указанный подход имеет целый ряд ограничений и в этом отношении более универсальным является предложенный нами метод «дисковых транзитов» [41,42,103], широко используемый нами и в других системах программирования.

Несомненным преимуществом метода «дисковых транзитов» является и то, что он распространяется на многие программные системы, не располагающие эффективными аналогами parse-функции, в частности, Mathematica, MathCAD и др. Поэтому, многие процедуры, использующие данный метод, существенно проще погружаемы в программную среду таких средств. Таким образом, средства нашей Библиотеки используют оба указанных метода при явном приоритете второго. Учитывая характеристики современных ПК (RAM, HDD, тактовая частота), а также их ближайшие потенции, оценивать эффективность обоих методов, на мой взгляд, задача достаточно неблагодарная. Однако, пользователь в качестве весьма полезных упражнений может поставить перед собой задачу привести все (или выбранные) процедуры нашей библиотеки [41,103,109] к единому методу. В принципе, представленные в ней средства далеко не всегда оптимизировались в строгом понимании этого понятия, хотя оценки эффективности для целого ряда из них и проводились. Нами таких целей не ставилось, ибо многие средства писались (что называется с листа) за один присест. Между тем, 4-летний период использования всех трех версий Библиотеки во многих научно-исследовательских организациях и университетах подтвердили вполне достаточную эффективность библиотеки как в качестве дополнения к пакету Maple, так и в качестве полезного учебного материала по курсу программирования в среде пакета. Надеемся, что и читатель найдет для себя кое-что полезное при освоении программной среды пакета Maple.

К parse-функции непосредственно примыкает и группа из двух функций sscanf, sscanf и процедуры scanf, имеющих следующие три формата кодирования:

(1) sscanf("<Строка>", "<Формат>") (2) fscanf(<Файл>, "<Формат>")

(3) scanf("<Формат>")

и предназначенная для обеспечения синтаксического анализа сканируемого содержимого строки, базирующегося на заданной форматирующей строке (формат), в соответствии с синтаксисом Maple. В этом отношении sscanf-функция сочетает возможности рассмотренной функции parse и printf-функции, рассматриваемой ниже. При этом, в качестве фактических значений string-типа для аргументов всех трех средств могут выступать и значения типа {symbol, name}.

Функция sscanf сканирует указанную Строку [конвертируя входящие в нее числа и подстроки согласно заданной форматирующей строки-конвертора (Формат)] и осуществляет их грамматический анализ в соответствии с Maple-синтаксисом, возвращая список сканированных компонент указанной первым аргументом строки. Форматирующая строка состоит из конвертирующих %-спецификаторов, имеющих следующую довольно простую структуру кодирования:

%{*} {<Длина>} <Код>

напоминающую структуру форматирующих %-спецификаторов рассматриваемой ниже процедуры printf. Здесь необязательный (*)-параметр указывает на то, что сканируемая компонента строки не должна появляться в составе возвращаемого sscanf-функцией результата. Параметр Длина определяет максимальную длину сканируемой части компоненты строки, которой соответствует данный %-спецификатор. Это позволяет выделять для конвертации и анализа подкомпоненты данной компоненты. Наконец, параметр “Код” определяет как тип сканируемой компоненты строки, так и тип возвращаемого элемента в выходном списке; его допустимые значения определяет следующая табл. 9.

Таблица 9

Следует иметь в виду, что непустые символы между %-спецификаторами форматирующей строки игнорируются, но должны по типу отвечать соответствующим символам сканируемой (считываемой/вводимой) строки. Функция fscanf (второй формат) отлична от sscanf-функции только тем, что сканируемая строка читается из файла, заданного его спецификатором (путь к нему в файловой системе ПК) в качестве фактического значения ее первого аргумента и открываемого как файл текстового формата. Функция fscanf читает строки файла целиком, но использует ровно столько символов, сколько требуется для обеспечения всех конвертирующих %-спецификаторов ее форматирующей строки. Остающиеся символы доступны для следующего вызова функции, так как файл остается открытым и указатель установлен на следующий считываемый символ.

При использовании {he|hf|hg}-кода следует иметь в виду, что сканируемые символы классифицируются на три типа: числовые, разделители и ограничители. К числовым относятся: цифры, десятичная точка, знаки (±) и символы {e, E, d, D}. Символы пробела, запятые или квадратные скобки полагаются разделителями, остальные - ограничителями. При этом, символ слэша "/" является идентификатором конца сканирования, а не символ обратного слэша "\", как указано в документации. Более того, в условиях Windowsплатформы недопустимыми являются форматирующие {D, O, X}-коды.

Наконец, третий формат (scanf) читает символы из стандартного входа и эквивалентен функции fscanf(<Стандартный вход>, <Формат>). В качестве стандартного входа по умолчанию полагается ввод с консоли (клавиатуры) ПК. Только успешно сканированные компоненты строки возвращаются в качестве элементов выходного списка, в противном случае возвращается пустой список,т.е. []. Если при сканировании компонент не обнаружено соответствующих форматирующей строке и реально достигнут конец ввода, то возвращается нулевое значение. Это же значение возвращается, если считывается пустой файл. Ряд сделанных ниже замечаний относительно форматирующей printf-процедуры сохраняет силу и для sscanf, fscanf и scanf. Следующий комплексный фрагмент иллюстрирует применение средств sscanf-группы для сканирования и синтаксического анализа строчных и символьных Maple-конструкций:

В частности, использование средств данной группы с русскими текстами может приводить к некорректным результатам, как это иллюстрирует второй пример фрагмента для Maple 8. Средства для работы с выражениями string–типа полностью применимы и к выражениям symbol-типа, ибо один тип легко конвертируется в другой, и наоборот. Поэтому, в отношении функциональных средств данные типы можно считать эквивалентными. При этом, так как, начиая с 6-го релиза, строчное выражение является индексируемым, т.е. к отдельному его символу можно адресоваться по номеру его позиции (например, "abcddfg"[3], "abcddfg"[3..5]; ⇒ "c", "cdd"), то к такого типа выражениям применимы и многие стандартные средства пакета, предназначенные для работы с индексированными структурами данных.

Ниже средства Maple-языка пакета для работы со строчными и символьными данными и их структурами будут рассматриваться в различных контекстах при представлении иллюстративных примеров. При этом, следует отметить, что по представимости работы со строчными структурами Maple-язык располагает меньшим количеством функциональных средств, чем упоминавшийся выше пакет Mathematica, что предполагает несколько большую искушенность пользователя в этом направлении. Правда, с последними релизами поставляется пакетный модуль StringTools, содержащий набор средств для работы со строчными структурами. Его появление, по-видимому, было навеяно нашим набором средств подобного типа, созданным еще для Maple V (все наши издания по Mapleтематике хорошо известны разработчикам ввиду имевшего места сотрудничества в процессе подготовки этих изданий). Между тем, представленные в нашей Библиотеке [103,108,109] средства работы со строчными и символьными выражениями существенно дополняют имеющиеся средства пакета для задач подобного типа.

Например, во многих приложениях, имеющих дело со строчными выражениями, широко используется процедура Red_n, обеспечивающая сведение кратности вхождений символов или подстрок в строку или символ. Вызов процедуры имеет формат Red_n(S, G, N), где: S – строка или символ, G – строка или символ длины >= 1 или их список и N – положительное целое (posint) либо список целых положительных чисел.

Вызов процедуры Red_n(S, G, N) возвращает результат сведения кратности вхождений символов или строк, заданных вторым фактическим аргументом G в строку или символ, указанный первым фактическим S аргументом, к количеству не большему, чем третий аргумент N. В частности, если N={1|2}, то строка/символ G удаляется из строки S или остается с кратностью 1 соответственно. Кроме того, тип возвращаемого результата соответствует типу исходного фактического S аргумента. Процедура Red_n производит регистро-зависимый поиск. Если символ G не принадлежит строке S, то процедура возвращает первый фактический аргумент без обработки с выводом соответствующего предупреждения. Нулевая длина второго фактического аргумента G вызывает ошибочную ситуацию с диагностикой типа «length of <> should be more than 1».

Если второй и третий фактические аргументы определяют списки, между которыми существует взаимно-однозначное соответствие, то сведение кратности делается по всем элементам списка G с соответствующими кратностями из списка N. Если nops(G) > nops(N), последние nops(G) - nops(N) элементов G будут иметь кратности 1 в возвращаемом результате. Если G – список и N – положительное целое число, то все элементы G получают одинаковую кратность N. Наконец, если G – символ или строка и N – список, то G получает кратность N[1] в возвращаемом результате. Процедура Red_n представляет собой достаточно полезный инструмент для обработки строк и символов при символьном решении задач [103]. Ниже представлены исходный текст процедуры и некоторые примеры ее применения.

Не меньший интерес представляет и seqstr-группа процедур, обеспечивающих различные режимы конвертации последовательностей выражений в строку [41,103]. Например, простая процедура seqstr1, реализованная однострочным экстракодом вида:

seqstr1 := () -> cat("", op(map(convert, [args], 'string')));

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

> seqstr1(), seqstr1(Z(x), x*y, (a + b)/(c + d), "ArtKr", 10/17)

"", "Z(x)x*y(a + b)/(c + d)ArtKr10/17"

Определенный интерес представляет и swmpat-группа процедур, обеспечивающих поиск образцов, содержащих wildcard-символы [103]. В качестве примера приведем swmpatпроцедуру. Вызов процедуры swmpat(S ,m, p, d {, h}) возвращает значение true, если и только если строка или символ, указанный фактическим аргументом S, содержат вхождения подстрок, которые соответствуют образцу m с группирующими символами, указанными четвертым аргументом d, тогда как третий фактический аргумент p определяет список кратностей соответствующих вхождений группирующих символов d в m.

Например, пусть триплет <"a*b*c", [4,7], "*"> определяет образец m="**** b ******* c". Вызов процедуры swmpat(S, m, [4, 7], "*") определяет факт вхождения в строку S непересекающихся подстрок, которые имеют вид образца m с произвольными символами вместо всех вхождений группирующего символа "*". При этом, если вызов процедуры swmpat(S, m, p, d, h) использовал необязательный пятый аргумент h и было возвращено значение true, то через h возвращается вложенный список, чьи 2-элементные подсписки определяют первые и последние позиции непересекающихся подстрок S, которые соответствуют образцу m. Кроме того, если образец m не содержит группирующие символы, то через h возвращается целочисленный список, чьи элементы определяют первые позиции непересекающихся подстрок S, которые соответствуют образцу m. Если же вызов процедуры возвращает значение false, то через h возвращается пустой список, т. е. [].

Если четвертый фактический аргумент d определяет строку или символ длины большей 1, то первый ее символ используется как группирующий символ. Если же список p имеет меньше элементов, чем количество вхождений группирующих символов в образец m, то избыточные вхождения получают кратность 1. По умолчанию, процедура swmpat поддерживает регистро-зависимый поиск, если вызов процедуры использует дополнительное ключевое insensitive-слово, то выполняется регистро-независимый поиск. Данная процедура имеет целый ряд весьма полезных приложений в задачах обработки строк и символов [103]. Ниже представлены исходный текст процедуры и примеры ее применения.

Отметим еще одну довольно полезную процедуру работы со строчными выражениями. Процедура nexts(S,A,B {,r}) обеспечивает поиск в строке или символе, определенных фактическим аргументом S, образцов B, ближайших к образцам А справа или слева. Вызов процедуры с тремя аргументами определяет поиск вправо от А, тогда как вызов с четырьмя или более аргументами определяет поиск влево от A. Вызов процедуры nexts(S, A, B {, r}) возвращает вложенный список, элементами которого являются 2-элементные списки (если вложенный список содержит только один элемент, то возвращается обычный список). Первый элемент такого подсписка определяет позицию образца А в S, тогда как второй определяет позицию образца B, ближайшего к А вправо или влево соответственно. Более того, если ближайший к образцу А образец B не был найден, то возвращаемый процедурой список будет содержать только позицию самого образца. Кроме того, в качестве аргумента A может выступать как образец, так и позиция отдельного символа в S. Если второй аргумент A отсутствует в S, то вызов процедуры возвращает false. Если какой-либо фактический аргумент пуст, то вызов процедуры вызывает ошибочную ситуацию. Во многих задачах обработки символов и строк данная процедура оказалась довольно полезным средством и используется рядом процедур нашей Библиотеки [103,109]. Ниже представлены исходный текст процедуры и некоторые примеры ее применения.

Наконец, вызов следующей процедуры SUB_S(L, S) возвращает результат выполнения подстановок, определенных аргументом L (список уравнений-подстановок), в строку либо символ S; при этом, очередная подстановка из L выполняется до ее полного исчерпания в строке S. Тип возвращаемого результата соответствует типу исходного аргумента S. В случае неприменимости подстановок L второй аргумент S возвращается без обработки.

В главе 5 [103] рассматриваются программные средства, расширяющие возможности пакета Maple релизов 6 - 10 при работе с выражениями типов {string, symbol}. Представленные в ней средства включены и в нашу Библиотеку [108,109], и обеспечивают множество полезных процедур таких как специальные виды преобразования, сравнение строк или символов, различные виды поиска в строках, обращение символов, строк или списков, исчерпывающие замены в строках или символах, сведение кратности вхождения символа в строку, определение вхождения специальных символов в строку и целый ряд иных. Во многих случаев данные средства существенно упрощают программирование с использованием объектов Maple типов {string, symbol, name} в среде пакета. Это актуально, в первую очередь потому, что символьные выражения составляют как основу важнейших структур пакета, так и основной объект символьных вычислений и обработки. Переходим теперь к рассмотрению средств обеспечения работы со структурами и данными списочного и множественного типов {list, set}, весьма широко используемых Maple-языком.

5.2. Средства работы Maple-языка с множествами, списками и таблицами

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

List:= [X1, X2, X3, ..., Xn] и Set:= {X1, X2, X3, ..., Xn}

где в качестве Xj-элемента (j=1, 2, 3, ..., n) могут выступать любые допустимые Maple-выражения, включая и сами структуры типов {list, set}, т.е. такие структуры допускают различные уровни вложенности, глубина которых ограничивается только доступным объемом оперативной памяти ПК. Пустой список (множество) обозначается как “[]” (“{}”). Следующий простой фрагмент иллюстрирует типичные структуры типов {list, set}, допускаемые Maple-языком пакета:

Результатом вычисления List-структуры (Set-структуры), как правило, является выражение list-типа (set-типа), тестируемое функциями type, typematch и whattype-процедурой, рассмотренными выше: по тестирующим функциям {type|typematch}(L, 'list') и whattype(L) возвращается соответственно значение true и list, если L – списочная структура. Аналогично обстоит дело и со структурами set-типа. Например, многие встроенные, библиотечные и модульные функции Maple-языка пакета возвращают результат типа {list, set}, как это весьма хорошо иллюстрирует следующий простой фрагмент:

> L:= [64, [sqrt(25), 2006], [a, b], {x, y}, 10.17\2006];

L := [64, [5, 2006], [a, b], {x, y}, 10.172006]

> type(L, 'list'), typematch(L, 'list'), whattype(L); ⇒ true, true, list

> Art:= "IAN 7 april 2006": sscanf(Art, "%a%d%a%d"); ⇒ [IAN, 7, april, 2006] > convert(G*sin(x)+S*sin(y)-ln(a+b)*TRG, 'list'); ⇒ [G sin(x), S sin(y), -ln(a+b) TRG]

> S:= "123456789": map(F, map(parse, [S[k]$k=1..9]));

[F(1), F(2), F(3), F(4), F(5), F(6), F(7), F(8), F(9)]

> fsolve({10*x^2 + 64*y - 59, 17*y^2 + 64*x -59}, { x, y});

{x = 0.7356456027, y = 0.8373164917}

> type(%, 'set'), typematch(%, 'set'), whattype(%); ⇒ true, true, set

> H:= "awertewasderaryretuur": Search2(H, {a, r, t}); ⇒ [1, 4, 5, 8, 12, 13, 14, 16, 18, 21]

В частном случае результатом вычисления или данными может быть и пустой []-список. По функции convert(B, 'list') можно конвертировать в списочную структуру вектор, таблицу или произвольное В-выражение, операнды которого будут элементами списка, как это иллюстрирует четвертый пример предыдущего фрагмента. Это же имеет место и в случае конвертации в set-структуру. С особенностями структур типов {list,set} можно ознакомиться в [39]. Структуры list-типа и set-типа во многих отношениях подобны, используя один и тот же базовый набор средств для их обработки. Ниже для удобства мы будем говорить о списочных структурах, везде (если не оговорено противного) предполагая и структуры set-типа. Наиболее существенная разница обоих типов структур состоит в следующем:

(1) если список – структура с четко определенным порядком элементов, заданным при его определении (при этом, ее элементы могут дублироваться), то для множество не имеет места четкое упорядочение элементов; (2) элементы множества не дублируются

Множество представляет собой структуру, элементы которой, в принципе, неупорядочены в принятом смысле (порядок ее элементов при создании в общем случае отличен от результата ее вычисления). Данная структура является аналогом математического понятия множества объектов. В отличие от списка, порядок ввода элементов множества при его определении отличается от порядка выходного множества, устанавливаемого согласно соглашениям пакета. Если в результате определения списочной структуры ее элементы только вычисляются, то в случае множества они дополнительно еще и упорядочиваются согласно адресов занимаемых ими ячеек памяти ЭВМ, а также производится приведение кратности вхождений идентичных элементов к единице. Однако можно показать, что между порядками элементов L-списка и M-множества, имеющих одинаковые длину и состав элементов, имеет место следующее определяющее соотношение (при этом, предполагается также, что L-список не имеет дублирования элементов, ибо во множестве М каждый элемент представляется в единственном экземпляре):

sort(L, 'address')[k] = M[k], где k – номер элемента объекта, например:

> L:= [h, g, s, a, x, [64, b], {y, c, z}, 59, Sv, 39, Art, 17, Kr, 10]: M:={ h, g, s, a, x, [64, b], {y, c, z},

59, Sv, 39, Art, 17, Kr, 10}: (sort(L, 'address')[k] = M[k])$k=1..14;

10 = 10, 17 = 17, 39 = 39, 59 = 59, [64, b] = [64, b], {c, z, y} = {c, z, y}, Sv = Sv, Art = Art, Kr = Kr, h = h, g = g, s = s, a = a, x = x

> sort(L, 'address') = M;

[10, 17, 39, 59, [64, b], {c, z, y}, Sv, Art, Kr, h, g, s, a, x] = {10, 17, 39, 59, [64, b], {c, z, y}, Sv, Art,

Kr, h, g, s, a, x}

> M:= { h, g, s, a, x, [64, b], {y, c, z}, 59, Sv, 39, Art, 17, Kr, 10};

M := {10, 17, 39, 59, [64, b], {c, z, y}, Sv, Art, Kr, h, g, s, a, x}

В определенных обстоятельствах данное соотношение может оказаться полезным при работе со структурами типов {list, set}. В свете сказанного во многих случаях можно рассматривать множества как упорядоченные объекты и использовать данное обстоятельство в различных приложениях. В общем же случае это не имеет места, поэтому использовать его следует весьма осмотрительно. Структуры и данные списочного типа являются весьма общим объектом и могут использоваться как самостоятельные типы данных, для которых язык располагает целым рядом средств представления и обработки, так и для организации составных вычислительных конструкций, о которых вскользь речь шла выше и по которым дополнительная информация дается ниже. Так как объекты, подобные векторам и матрицам, в среде пакета представляются списочными структурами, то ряд средств поддержки работы с первыми может быть успешно использован и непосредственно для списков, как и наоборот. В свете определения списочной структуры, она представляется весьма удобной для более компактного представления результатов вычисления выражений, как это иллюстрировалось выше. Более того, результат вычисления списка возвращает вновь списочную структуру с сохранением порядка элементов исходного списка. Рассмотрим детальнее базовые средства работы со списками. При этом, для удобства и не оговаривая отдельно, в представляемых форматах функций в качестве их L-аргументов понимается списочная структура (список) и, если не оговорено противного, также и множество с учетом указанных различий между ними. Там, где имеются различия, они будут отмечаться.

По упоминаемой выше op(L)-функции можно “снимать” списочную структуру, превращая L-список (множество) в последовательность (exprseq) его элементов, а по вызову функции nops(L) – получать число его элементов (длину списка/множества). По конструкциям вида: L[k] и L[k]:= <Выражение> соответственно возвращается к-й элемент и изменяется значение к-го элемента L-списка путем присвоения ему значения указанного выражения, тогда как по NULL-значению (L[k]:=NULL) удалять к-й элемент невозможно, т.к. возникает ошибочная ситуация с диагностикой «Error, expression sequences cannot be assigned to lists». Для этой цели следует использовать вызов subsop(k=NULL, L) или прием, представленный в разделе 1.5. Тогда как для случая М-множества вторая конструкция заменяется, например, следующими: S:= [op(M)]: S[k]:= <Выражение>: M:= {op(S)}. Наоборот, по конструкции {[<exprseq>]|{<exprseq>}} производится конвертация последовательности (exprseq) в структуру типа {list|set} соответственно или это можно сделать по рассмотренной convert-функции.

Два случая применения op-функции следует рассмотреть особо. Как уже отмечалось выше, по конструкции op(0, B) в общем случае возвращается тип B-выражения. Однако для индексированных структур и функций возвращаются их идентификаторы, тогда как для некоторых других структур, например, последовательностей (exprseq), может инициироваться ошибочная ситуация. Наконец, в случае третьего формата op-функции (раздел 1.3) первый ее аргумент op(p1, B) определяет p1-позицию выделяемого элемента 1-го (внешнего) уровня вложенности В-выражения {B1=op(p1, <Выражение>)}, p2 – позицию выделяемого элемента из В1 {B2 = op(p2, В1)} и т.д., т.е. имеет место следующее определяющее соотношение:

op([p1, p2, ..., pn], <Выражение>) ≡ op(pn, ... op(p3, op(p2, op(p1, <Выражение>)))...)

Следовательно, третий формат op-функции ориентирован на работу с вложенными списочными структурами, а в общем случае с Maple-выражениями, имеющими несколько уровней вложенности. Следует иметь в виду, что вычисления в списочной структуре ориентированы и производятся не независимо, а поэлементно слева направо (включая уровни вложенности), именно поэтому результаты вычислений можно передавать между элементами списка в указанном направлении, что весьма существенно при организации вычислений и будет использоваться нами в дальнейшем. Функции {op, nops} очень широко используются и для произвольных выражений, но для списочных структур и множеств они являются одними из базовых средств по манипулированию их элементами, включая и уровни их вложенности. Например, по конструкции L:=[op(L), <Элемент>] производится пополнение L-списка новым указанным элементом, например:

> L:=[64,59,39,10,117]: L:=[op(L),V,G,Sv,Kr,Art]; ⇒ L:= [64, 59, 39, 10, 117, V, G, Sv, Kr, Art] Данная конструкция широко используется в практическом программировании задач.

Для возможности символьной обработки уравнений, неравенств, отношений и диапазонов важно иметь средства выделения их {левой|правой} части или {начального|конечного} выражения диапазона, что обеспечивается соответственно {lhs|rhs}-функцией, имеющей простой формат кодирования, а именно: {lhs|rhs}(V), где V – Maple-выражение одного из указанных типов {relation, range}. Следующий фрагмент достаточно прозрачен и каких-либо особых пояснений не требует:

> [map(rhs, [A = B, A <>B, A <+ B, A .. B]), op(A <>B)]; ⇒ [[B, B, B, B], A, B]

> map(op, [A = B, A <>B, A <+ B, A .. B]); ⇒ [A, B, A, B, A, B, A, B]

> [op(k, A = B), op(k, A <> B), op(k, A <= B), op(k, A..B)]$k=1..2; ⇒ [A,A,A,A], [B,B,B,B] Приведенный фрагмент иллюстрирует не только эквивалентность (легко следующую из определения функций op и {lhs|rhs}, конструкций {lhs|rhs}(V) и op({1|2}, V), но и возможность по конструкции op(V) получать список, элементами которого являются левая и правая части V-выражения (уравнение, неравенство, отношение, диапазон).

Функция member, имеющая в общем случае следующий формат кодирования:

member(<Выражение> {, <Список>|, <Множество>} {, '<Идентификатор>'})

выполняет тестирование указанного списка/множества на предмет вхождения в него указанного первым аргументом выражения. При кодировании необязательного третьего аргумента (должен быть невычисленный идентификатор) ему присваивается номер позиции первого вхождения заданного выражения в список/множество, если member-функция возвращает true-значение; иначе идентификатор остается неопределенным. Данная функция весьма широко используется при практическом программировании. В качестве ее расширения была определена процедура belong [103,109], обеспечивающая тестирование принадлежности указанного выражения множеству, списку, модулю, процедуре, символу, строке и другим типам выражений. Ниже представлены ее исходный текст и некоторые примеры применения.

Данная процедура существенно расширяет встроенную функцию member, упрощая в целом ряде случаев программирование приложений в среде пакета.

Начиная с 8-го релиза, Maple-язык расширен новым in-оператором, имеющим формат: el in L или `in`(el, L)

где el - произвольное Maple-выражение и L - список либо множество. Назначением данного оператора является тестирование на принадлежность el к L. Результатом применения данного оператора является возврат исходного вызова в принятой математической нотации, тогда как для получения собственно результата тестирования к полученному результату следует применять evalb-функцию. Весьма простые примеры иллюстрируют вышесказанное:

> 64 in [59, 39, 64, 10, 17, 44]; evalb(%); ⇒ 64 ∈ [59, 39, 64, 10, 17, 44] true

> evalb(`in`(64, [59, 39, 64, 10, 17, 44])); ⇒ true

Детальнее с данным оператором in можно ознакомиться в справке по пакету.

К member-функции по смыслу, но с более широкими возможностями, примыкает и процедура charfcn[A](X), являющаяся характеристической для множеств и алгебраических Maple-выражений. В качестве Х выступает произвольное алгебраическое выражение, а в качестве А - спецификатор множества. Кусочно-определенная charfcn-процедура задается следующим определяющим соотношением:

1, если Х удовлетворяет А-спецификатору

charfcn[A](X) =0, если Х не удовлетворяет А-спецификатору

^  'charfcn[A](X)', в противном случае

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

Таблица 10

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

> charfcn[64, 59, 39, 10, 17](17), charfcn[64, 59, 39, 10, 17](44); ⇒ 1, 0

> charfcn[1 .. 64](59), charfcn[3.1 .. 3.3](Pi), charfcn[2+I .. 17+2*I](2+I); ⇒ 1, 1, 1 > G:= X -> 64*charfcn[1..9](X)+59*charfcn[10..17](X)+39*charfcn[18..25](X)+17* charfcn[-infinity .. 0, 26..infinity](X): map(G, [2, 12, 20, -3, 32]); ⇒ [64, 59, 39, 17, 17]

Последний пример фрагмента иллюстрирует использование характеристической функции charfcn для определения кусочно-определенной G-функции.

Следующие две функции select и remove, имеющие идентичный формат кодирования:

{select|remove}(ТФ, <Выражение> {, <Фактические аргументы>})

позволяют {выбирать|удалять} из указанного выражения только те его операнды (элементы), которые на заданной тестирующей функции (ТФ) возвращают true-значение. При этом, необязательный третий аргумент {select|remove}-функции позволяет передавать для ТФ необходимые фактические аргументы, например, фактические значения для второго аргумента функции {type|typematch}. Функция {select|remove} применима к спискам, множествам, суммам, произведениям и функциям, возвращая конструкции, тип которых определяется типом исходного выражения, например:

> select(type, [64,59,39,10,17],'even'), remove(type, [64,59,39,10,17],'odd'); ⇒ [64,10], [64,10]

По subsop-функции, имеющей следующий простой формат кодирования: subsop(p1 = B1, p2 = B2, ... ,pn = Bn, <Список/Множество>)

производится замена всех элементов указанного списка/множества, находящихся на его pj-позициях, на указанные Bj-выражения; в случае вложенного списка/множества в качестве pj-позиций указываются списки (подобно рассмотренному для случая op-функции). Если subsop-функция не содержит уравнений замены (pj = Bj), то указанный список/множество возвращается без изменения. В общем случае, функция subsop применима к любому Maple-выражению, содержащему операнды. При этом, нулевые значения для pjпозиций допустимы только для выражений типа функция, индексированное выражение или ряд. Замечания, сделанные относительно op-функции, сохраняют силу и для функции subsop, например:

> subsop(1=42, 2=47, 3=76, 4=96, 5 = 89, [64, 59, 39, 10, 17]); ⇒ [42, 47, 76, 96, 89]

Близка к subsop-функции по идеологии и applyop-процедура с форматом кодирования: applyop(F, p, <Выражение> {, <Фактические аргументы>})

и применяющая указанную своим идентификатором F-функцию к операнду, находящемуся на заданной р-позиции выражения; при необходимости можно определять фактические аргументы для передачи их F-функции. Аргумент позиция (р) applyop-процедуры определяется номером позиции операнда (элемента), списком позиций (аналогично случая subsop-функции) либо множеством позиций операндов, к которым F-функция применяется одновременно. Особенности выполнения процедуры см. в прилож. 1 [12]. Приведем простой пример применения процедуры applyop:

> applyop(F, {1, 2, 3}, [x, y, z], a, b, c, d); ⇒ [F(x, a, b, c, d), F(y, a, b, c, d), F(z, a, b, c, d)]

В отличие от applyop-процедуры ранее упоминавшаяся map-функция с форматом: map(F, <Выражение> {, <Фактические аргументы>})

позволяет применять F-функцию/процедуру, заданную своим идентификатором, к каждому операнду указанного выражения с возможностью передачи F-функции необходимых фактических аргументов, которые в общем случае кодирования map-функции необязательны. По map-функции указанная F-функция применяется ко всем элементам структур типа {list, set, array, table}. Дальнейшим расширением данной функции является map2-функция, также рассмотренная нами выше. Следующий прозрачный фрагмент иллюстрирует применение обоих функций с акцентом на их различиях:

> map(G, [x, y, z, u], a, b, c); ⇒ [G(x,a,b,c), G(y,a,b,c), G(z,a,b,c), G(u,a,b,c)]

> map2(G, [x, y, z, u], a, b, c); ⇒ G([x, y, z, u],a,b,c)

> map(G, t, [x, y, z, u], a, b, c); ⇒ G(t, [x, y, z, u], a, b, c)

> map(map2, [x, y, z], a, d, c); ⇒ [x(a,d,c), y(a,d,c), z(a,d,c)]

> map2(map, [x, y, z], a, d, c); ⇒ [x(a,d,c), y(a,d,c), z(a,d,c)]

> map(map2, h, [x, y, z], a, d, c); ⇒ h([x, y, z],a,d,c)

> map2(map, h, [x, y, z], a, d, c); ⇒ [h(x,a,d,c), h(y,a,d,c), h(z,a,d,c)]

В порядке расширения возможностей функций map и map2 нами создан ряд подобных процедур map3 .. map6 и mapN [41,103]. В частности, вызов процедуры mapN(F, p, x1, x2, …, xn, [a, b, c, …]) возвращает результат вычисления функции F от аргументов <x1, x2, …, xn> при условии получения его p-м аргументом значений из списка или множества, определенного последним фактическим аргументом процедуры. Процедура представляется достаточно полезным дополнением к вышеупомянутым двум стандартным функциям пакета. Ниже представлены исходный текст процедуры mapN и пример ее применения.

По вызову функции subs(L, <Выражение>) возвращается результат подстановки в указанное вторым аргументом выражение всех вхождений левых частей уравнений, определяемых списком/множеством L, на их правые части. При этом, в качестве L-аргумента может выступать и отдельное уравнений (отдельная подстановка). Подстановка правых частей уравнений производится одновременно, используя естественный порядок уравнений в L-списке/множестве. Более того, подстановке подвергаются только операнды исходного выражения, распознаваемые op-функцией, независимо от уровня их вложенности. Однако, подстановка производится только для строгого вхождения левых частей уравнений, определяя так называемую синтаксическую подстановку. При этом, подстановка не влечет за собой непосредственного вычисления выражения и для этих целей следует использовать затем eval-функцию, которая, однако, в общем случае не обеспечивает полного вычисления результата подстановки, как это иллюстрируют примеры следующего простого фрагмента:

> subs([x=a,y=b,z=c], [x,y,z,a*x, b*y, c*z, x+y+z, x*y*z]); ⇒ [a b c a, , , 2, b2, c2, a + b + c a b c, ]

> subs(x=Pi, sin(x)+cos(x)), eval(subs(x=Pi, sin(x)+cos(x))); ⇒ sin(π) + cos(π), -1

> subs([ooo=a,aao=b,oaa=c,aoa=d], [ooo,aao,oaa,ooo,aoa,aao,aao,oaa]); ⇒ [a, b, c, a, d, b, b, c] > subs([oo=NULL, aa=NULL, ao=NULL, oa=NULL], [oo, aa, aa, oo, ao, aa, ao, oa]); ⇒ [] > subs({oo=NULL, aa=NULL, ao=NULL, oa=NULL}, {oo, aa, aa, oo, ao, aa, ao, oa}); ⇒ {}

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

Под структурой listlist-типа понимается вложенный список, все элементы первого (внешнего) уровня которого являются списками той же длины, что и содержащий их список, например: [[a, b, c], [d, e, f], [g, h, i]]. Такой объект распознается type-функцией как объект listlist-типа, например, type([[a,b,c], [d,e,f], [g,h,i]], 'listlist'); ⇒ true. По convert-функции можно конвертировать {список|массив} в список списков (listlist); при этом, сам список должен задаваться уравнениями вида <позиция списка> = <элемент списка>. Однако в ряде версий 6-го релиза вызов convert(R::array, listlist) вызывает ошибочную ситуацию с диагностикой "Error, in convert/old _ array_to_listlist) Seq expects its 2nd argument .… ". Для устранения данной ситуации может использоваться модификация стандартной функции – процедура 'convert/listlist1' [41,103,109], которая обеспечивает конвертацию списка, множества, массива либо rtable-объекта в listlist-объект, например:

> convert([2=64, 3=10, 4=39, 5=59, 1=17, 6=44], 'listlist1'); ⇒ [17, 64, 10, 39, 59, 44]

В ряде задач, имеющих дело со структурами list-типа, возникает потребность использования так называемых вложенных структур списков (nestlist). Скажем, список – вложенный список, если по крайней мере один его элемент имеет list-тип. Для проверки списка быть вложенным списком служит расширение стандартной type-функции [103]. Вызов процедуры type(expr, 'nestlist') возвращает true, если список, определенный первым фактическим expr аргументом является вложенным списком, и false в противном случае, например:

> L:= [a, c, [h], x, [a, b, []]]: type([], nestlist), type([[]], nestlist), type(L, nestlist), type([[[]]], nestlist), type([[61], [56], [36], [7], [14]], nestlist), type([a, b, c, {}], nestlist); false, true, true, true, true, false

В ряде задач, имеющих дело со структурами set-типа, возникает потребность использования так называемых setset-структур (аналогично listlist). Скажем, множество имеет тип 'setset', если его элементы – множества того же самого количества элементов. Для проверки множества на setset-тип служит расширение стандартной type-функции [41,103], т.е. вызов процедуры type(S, 'setset') возвращает true, если множество, определенное первым фактическим S аргументом, имеет setset-тип, и false в противном случае, например:

> map(type, [{{}}, {{},{}}, {{{7}}}, {{a, b}, {c, d}}, {{a, b}, {c}}, {{10, 17}, {64, 59}, {39, 44}}], 'setset');

[true, true, true, true, false, true]

По функции sort(L {, СФ}) производится сортировка элементов L-списка либо согласно принятому в пакете соглашению (определяемому типом элементов списка), либо согласно заданной сортирующей функции (СФ), устанавливающей приоритет между любыми двумя элементами списка. А именно, СФ G(x, y) возвращает {true|false}-значение в зависимости от {соответствия|несоответствия} двух смежных {x, y}-элементов L-списка и в зависимости от него {не меняет|меняет} их местами в выходном L`-списке. Наиболее типичными примерами СФ, поддерживаемыми Maple-языком, являются: address, numeric, `<` и lexorder; при этом, первая и последняя определяют сортировку соответственно адресную (в соответствии со значениями адресов, занимаемыми в памяти элементами списка) и лексикографическую. Если СФ-аргумент sort-функции не указан, то числовой список сортируется согласно значениям чисел в порядке их возрастания, символьный (строчный) список – в лексикографическом порядке, в остальных случаях производится адресная сортировка, которая зависит от текущего сеанса работы с пакетом (в свете планирования для пакета памяти ПК). Пользователь имеет возможность определять собственные СФ, решающие специфические задачи сортировки; один из примеров такой СФ (SF) приведен в нижеследующем простом фрагменте:

> SF:=(X::{string,symbol}, Y::{string,symbol}) -> `if`(""||X = "" and ""||Y = "" or ""||X="", true, `if`(""||Y = "", false, `if`(sort([(""||X)[-1], (""||Y)[-1]], 'lexorder')[1] = (""||X)[-1], true,false))): sort(["12345", xyz, `123d`, "123a", `123c`, ``, abc, "", ta,avz64, agn59, vsv39],SF);

[``, "", avz64, "12345", agn59, vsv39, "123a", ta, 123c, abc, 123d, xyz]

Для работы со списками и множествами нами был предложен целый ряд достаточно полезных процедур [103], в частности, полезной во многих приложениях является процедура SLj, обеспечивающая сортировку вложенных списков на основе заданных позиций элементов их подсписков. Ниже представлены ее исходный текст и пример применения.

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

> f:= () -> `+`(args): snl([[2,6,9], [11,34,47], [67,2,10,18]], f, [1, 2, 3], `>`);

[[11, 34, 47], [67, 2, 10, 18], [2, 6, 9]]

> snl([[2,6,9], [11, 34, sin(18)], [67, 2, 10, 18]], f, [1, 2, 3]);

[[2, 6, 9], [11, 34, sin(18)], [67, 2, 10, 18]]

> snl([[2,6,9], [11,34,47], [67,2,10,18]], f, [1, 2, 5], `>`);

Error, (in snl) sublist [2, 6, 9] have length more than maximal element of list [1, 2, 5] > snl([[2,6,9], 2007, [67,2,10,18]], f, [1, 2, 3]);

Error, (in snl) element 2007 has a type different from list or is non-numeric list

Первый аргумент вызова процедуры snl(L, f, p) определяет вложенный список, тогда как второй определяет процедуру, чьи фактические аргументы получают в качестве значений элементы подсписков L, стоящие на указанных аргументом р позициях. Подсписки L по умолчанию сортируются в зависимости от значений f(x1, x2, …) согласно функции упорядочивания `<=`; четвертый необязательный аргумент определяет упорядочивающую функцию из множества {`<`, `<=`, `>`, `>=`}. Сортировке подвергаются только числовые вложенные списки, в противном случае инициируется ошибочная ситуация.

Нижеследующий фрагмент первым примером представляет процедуру, обеспечивающую один вид полезной конвертации произвольного Maple-выражения L на основе составляющих его операндов. В частности, данный тип конвертации достаточно полезен в случае необходимости конвертации списка/множества в выражение, представляющее собой «склейку» входящих в исходной объект элементов. Тогда как второй пример фрагмента представляет один полезный вид сортировки списочных структур на основе процедуры slsa, использующей представленные выше процедуры.

Вызов процедуры slsa(L) возвращает результат сортировки списка L с элементами типов {algebraic, string, symbol} в порядке возрастания элементов. При наличии второго необязательного аргумента relation1-типа сортировка определяется заданным отношением. При этом, в начале отсортированного списка находятся (если имеются) элементы с числовыми эначениями а (для которых type(evalf(a), ‘numeric’) ⇒ true), за которыми следуют (при наличии) элементы других допустимых типов.

В свете сказанного, во многих случаях можно рассматривать множества как упорядоченные объекты и использовать данное обстоятельство в различных приложениях. В общем же случае это не имеет места, поэтому использовать его следует весьма осмотрительно. Именно по этой причине для удаления элемента из множества недопустимо использование конструкций, рассмотренных выше для случая списочных структур. Этих целей нами был предложен ряд средств [41,103,108,109]. В частности, нижеследующая процедура

Вызов процедуры insituls(L, a) обеспечивает обновление элементов списка/множества L «на месте»; при этом, a-аргумент может быть уравнением либо списком/множеством уравнений, определяющих замены в L. Левые части уравнений определяют текущие элементы списка/множества L, тогда как его правые – замены для текущих элементов. В частности, NULL в качестве правой части удаляет соответствующий элемент из L. Успешный вызов процедуры возвращает NULL-значение, выполняя требуемое обновление списка/множества L «на месте».

Реализованная однострочным экстракодом процедура insitudelL, обеспечивает удаление «на месте» элементов списка L, заданных списком/множеством их позиций Р [103,109].

В ряде задач работы со вложенными списками/множествами требуется определять элементы с максимальным/минимальным уровнем вложенности. Здесь может быть полезна процедура mlsnest. Вызов процедуры mlsnest(L) возвращает 2-элементный вложенный список, чей первый подсписок содержит номер элемента списка/множества L и минимальный уровнь его вложенности, тогда как второй подсписок определяет элемент L и максимальный уровнь его вложенности. При вызове mlsnest(L, 't') через t возвращается дополнительно множество всех уровней вложенности списка/множества L.

По вызову функции convert(B, 'set') можно конвертировать в структуру set-типа массив, таблицу или произвольное В-выражение, чьи операнды становятся элементами множества. При этом, операция конвертации список ⇒ множество ⇒ список в общем случае не является обратимой, хотя оба типа структур и базируются на общей последовательностной (exprseq) структуре.

Из рассмотренных выше средств по работе со списочными структурами кроме sort-функции остальные распространяются и на множества, не требуя дополнительных пояснений. Однако в случае необходимости любая функция, работающая со списочными структурами, может быть использована и с множествами, конвертировав их предварительно в списки. Этому способствует и то обстоятельства, что конвертация типа: множество ⇒ список ⇒ множество является обратимой, в отличие от конвертации типа: список ⇒ множество ⇒ список. Вместе с тем, структуры типа множество обеспечены Maple-языком рядом специальных функций для поддержки теоретико-множественных операций.

Для обеспечения работы с множествами Maple-язык пакета поддерживает три базовых теоретико-множественных оператора/функции, имеющих форматы кодирования:

M1 {union|intersect|minus} M2 {`union`|`intersect`|`minus`}(M1, M2, …, Mn)

и возвращающие соответственно результаты объединения (union), разности (minus) и пересечения (intersect) Mk-множеств (k = 1..n). Операторы {union, intersect} являются n-местными, инфиксными, ассоциативными и коммутативными, а minus - инфиксным бинарным оператором. Приведем простой пример на применение данных средств:

> `union`({a,b,c}, {x}), `intersect`({a,b,c}, {a,c}), `minus`({a,b,c}, {b}); ⇒ {a, b, c, x}, {a, c}, {a, c}

Рассмотренные в настоящем разделе средства Maple-языка для работы со списочными структурами и множествами будут в различных контекстах (глубже проясняющих их суть и назначение) использоваться при представлении разнообразных иллюстративных примеров. Между тем, следует иметь в виду, что наряду с рассмотренными пакет в рамках модульной части главной библиотеки предоставляет ряд функций по работе с рассмотренными структурами (списки и множества), поддерживаемых, в первую очередь, модулями combinat и totorder, позволяющими соответственно использовать комбинаторные операции со списками и упорядоченными множествами. Начиная с 7-го релиза, поставляется и модуль ListTools, содержащий набор средств для работы со списочными структурами. Его включение, по-видимому, было навеяно нашим набором средств подобного типа, созданных еще для Maple V (все наши издания по Maple-тематике хорошо известны разработчикам). Однако, не взирая на это, представленные в {103] средства работы со списками и множествами существенно дополняют имеющиеся средства пакета. Наконец, из-за пересечения свойств ряда типов структур, поддерживаемых пакетом, многие его функции в этом отношении многоаспектны, поэтому со списочными структурами и множествами допустимо использование и не только специфических для них средств.

Табличные объекты . Табличный объект (либо просто таблица) создается по встроенной функции table(F, L), где F – индексная функция и L – список/множество начальных входов таблицы. При этом, оба аргумента необязательны. Более того, создавать таблицу можно как явно по table-функции, так и неявно путем присвоения выражений индексированному идентификатору. В обоих случаях созданный объект опознается тестирующими средствами Maple-языка как таблица, например:

> T:= table([V=64, G=59, S=39, Art=17, Kr=10]): H[V]:=64: H[G]:=59: H[S]:=39: H[Art]:=17: H[Kr]:=10: map(type, [T, H], 'table'), map(typematch, [T, H], 'table'), map(hastype, [T, H],

'table'), map(whattype,map(eval, [T,H])); ⇒ [true, true], [true, true], [true, true], [table, table]

В отличие от массивов, у которых индексы должны быть целочисленны, входы (или индексы) таблицы могут быть любыми Maple-выражениями. Данное обстоятельство определяет важность и распространенность использования табличных объектов. В частности, в качестве входов таблицы могут выступать имена процедур, а выходов – соответствующие им определения. Ряд пакетных модулей организованы именно таким образом.

Функция table создает таблицу с начальными значениями, определяемыми L. Если L – список или множество уравнений, то левые части L становятся входами таблицы, а правые части ее выходами. В противном случае, элементы L становятся выходами таблицы, а входами становятся целые числа, начиная с 1. Использование множества начальных значений L в последнем случае неоднозначно, т.к. отсутствует порядок элементов множества, и следовательно порядок вхождений в результате может не соответствовать порядку, в котором вхождения были сделаны. Если аргумент L не определен, то создается пустая таблица, т.е. table([]). Новый вход в таблицу Т можно добавлять по конструкции T[Вход]:= <Выход>. По таким же конструкциям можно и создавать таблицу неявно. Удаление входов из таблицы Т можно выполнять по конструкции T[<Вход>]:= 'T[<Вход>]', например, Т[a]:= 'T[a]' удаляет из таблицы T элемент со входом a. При этом, обновление таблицы производится «на месте». Между тем, в ряде случаев более удобным является применение для этих целей нашей процедуры detab [103,108,109].

Достаточно простая процедура detab(T, a {, b}) возвращает результат удаления из таблицы Т элементов с входами, определенными вторым а-аргументом, в качестве которого может выступать как отдельный вход, так и их список/множество. В случае кодирования третьего необязательного аргумента (произвольное Maple-выражение) обновление таблицы Т удаляемыми элементами производится «на месте», т.е. обновляется сама исходная таблица Т. Выше представлены исходные тексты двух реализаций процедуры и некоторые примеры ее применения.

Замечание. Подход, реализованный в данной процедуре, может быть успешно применен в тех случаях, когда требуется вызовом процедуры обновлять вычисленные Maple-объекты, находящиеся вне тела самой процедуры, т.е. глобальные относительно ее и выступающие даже в качестве фактических аргументов. При этом, следует иметь в виду, что если в качестве обновляемых выступают объекты, не использующие специальных вычислительных правил подобно таблицам и процедурам (т.е. обращение к ним возвращает их идентификаторы, а не значения), то при указании их в качестве формального аргумента им следует присваивать uneval-тип. Второй способ реализации detab-процедуры иллюстрирует вышесказанное. Между тем, операцию обновления «на месте» следует выполнять довольно осмотрительно во избежание возможной рассинхронизации вычислительного процесса в целом.

Функция индексации F может быть процедурой или идентификатором, определяющим каким образом должна выполняться индексация; по умолчанию полагается обычная индексация. В качестве встроенных функций индексации пакет допускает: symmetric, antisymmetric, sparse, diagonal и identity. Для дополнительной информации об этих функциях см. ?indexfcn.

Таблицы имеют специальные правила вычисления (подобно процедурам) такие, что если имя T было присвоено таблице, то type(T, 'symbol') = true и type(eval(T), 'table') = true. Вызов op(T) либо op(1, T) возвращает фактическую структуру таблицы Т и op(op(T)) либо op(2, eval(T)) возвращает компоненты таблицы в составе функции индексации (если существует) и списка уравнений для значений таблицы, как это иллюстрирут следующий весьма простой фрагмент:

> T:=table([x=a, y=b, z=c]): type(T, 'symbol'), type(eval(T), 'table'), whattype(T), whattype(eval(T)); ⇒ true, true, symbol, table

> op(T), op(1, T); ⇒ table([z = c, y = b, x = a]), table([z = c, y = b, x = a])

> op(op(T)), op(2, eval(T)); ⇒ [z = c, y = b, x = a], [z = c, y = b, x = a]

Функция indices(T) возвращает входы таблицы Т, тогда как функция entries(T) – ее выходы. В то же время формат возврата не всегда удобен для его последующего использования. Поэтому второй пример нижеследующего фрагмента приводит более приемлемый формат, в котором между обоими возвращаемыми списками имеет место взаимно-однозначное соответствие:

> indices = indices(T), entries = entries(T); ⇒ indices = ([z], [y], [x]), entries = ([c], [b], [a]) > indices = map(op, [indices(T)]), entries = map(op, [entries(T)]); indices = [z, y, x], entries = [c, b, a]

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

В приведенном фрагменте в табличную ST-структуру погружаются две простые процедуры. Вызов with(ST) для которой возвращает список находящихся в ней процедур, тогда как индексированные вызовы этих процедур на кортежах фактических аргументов возвращают искомые результаты – их среднюю и дисперсию. После чего процедура UpLib [41] сохраняет ST-таблицу в библиотеке пользователя UserLib, которая логически сцеплена с главной библиотекой Maple. После выполнения restart-предложения делается попытка обратиться к сохраненной таблице аналогично модуля, что вызывает соответствующую ошибочную ситуацию. Ошибку вызывает и процедура ParProc(ST) [103], тестирующая параметры процедур, программных и пакетных модулей. Тогда как индексированный вызов дает корректные результаты. Наконец, сохраненная ST-таблица распознается как пакет

(пакетный модуль в нашей терминологии {табличной организации}) и таблица, а также процедурой M_Type(ST) [103,109] как пакет табличной организации. Следует отметить, например, что Maple 8 содержит 34 пакета табличной организации, Maple 9 – 23, а вот уже Maple 10 только 16. Статистика говорит о снижении количества пакетов табличной организации с ростом номера релиза Maple. Между тем, они все еще играют весьма существенную роль, о чем говорит следующий пример:

> map(M_Type, [Slode, context, plots, simplex, student, tensor, DEtools, diffalg, LREtools,

PDEtools, algcurves, orthopoly, combstruct, difforms, inttrans, networks]); # Maple 10

[Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab, Tab]

Обсуждение причин такого явление не входит в задачи данной книги. Заинтересованный же читатель может обратиться к нашим книгам [41,42,45,46,103]. Для работы с выражениями типов {list, table, set} Maple-язык располагает целым рядом средств, основные из которых были представлены либо упомянуты в настоящем разделе. Ряд достаточно полезных средств для обработки такого типа выражений представляет и наша Библиотека [103], демо-версию которой и саму Библиотеку можно загрузить с адресов [108,109].

Так, глава 6 [103] представляет средства, расширяющие возможности Maple-языка при работе с объектами типов {list, set, table}. Списочные структуры играют чрезвычайно важную роль, определяя упорядоченные последовательности элементов. Начиная с Maple 6, появилась возможность существенного расширения операций со списочными структурами. В качестве примера, имеющего интересные практические приложения, мы рассматриваем определение алгебры на множестве всех списков, имеющих одну и ту же длину. Алгебраические операции над списками обеспечивают соответствующие процедуры. Ряд процедур главы поддерживает полезные виды обработки типа: специальное преобразование списков в множества, и наоборот, операции с разреженными списками, динамические присваивания значений элементам списка или множества, оценка входов таблицы по ее выходу, представление специального типа таблиц, специальные виды исчерпывающих подстановок в списки или множества, целый ряд важных видов сортировки вложенных списков, и много других. Данные инструментальные средства оказались достаточно полезными при работе с объектами вышеупомянутых типов в среде Maple.

5.3. Алгебраические правила подстановок для символьных вычислений

Для решения задач символьной обработки, имеющих дело с формальными системами подстановок, Maple-язык располагает средствами обеспечения работы с алгебраическими правилами подстановок. Данные средства представляют основной аппарат при исследованиях формальных систем обработки слов в конечных алфавитах и абстрактных моделей вычислений. Основным понятием здесь является правило подстановки, определяемое группой функций subs, subsop и процедур algsubs, asubs.

По первой уже рассматриваемой функции subs({x = a|<УР>}, V) производится подстановка a-выражения вместо каждого вхождения х-выражения в V-выражение или одновременная подстановка правых частей уравнений (УР), заданных списком/множеством, вместо всех вхождений в V-выражение соответствующих им левых частей уравнений. При этом, по subs-функции делаются подстановки лишь для вхождений левых частей уравнений (правил подстановки) в качестве операндов V-выражения. Такого типа подстановки носят своего рода синтаксический характер, глубоко не затрагивая структуры V-выражения. Результатом подстановки не является вычисление и при необходимости выполнения полного вычисления результата подстановки требуется применение eval-функции, как показано на фрагменте, представленном несколько ниже.

Для возможности обеспечения выборочных подстановок служит специальная subsop(n1 = V1, n2=V2, ...., np=Vp, W)-функция, по которой производится замена на правые Vj-части уравнений операндов W-выражения, определяемых их nj-номерами. При этом, в качестве левых nj-частей допустимо использование списков целочисленных выражений, определяя подоперанды W-выражения в порядке понижения их уровней вложенности. Целочисленные значения должны находиться в диапазоне [-nops(), nops(W)], а нуль-значение допустимо только для функций, индексированных выражений и рядов. В случае nj отрицательного номер полагается равным nops(W) + nj + 1.

По процедуре asubs(∑ = V, W {, x|, x, always|, always}) производится подстановка в Wвыражение аналогично случаю subs-функции, однако она носит скорее алгебраический, чем синтаксический характер, допуская в качестве левой ∑-части уравнения (правила подстановки) использование сумм операндов полиномиального типа, замещающих соответствующие им суммы в исходном W-выражении. При этом, замена сумм производится только в том случае, если левая ∑-часть правила подстановки и соответствующее ей подвыражение W-выражения являются развернутыми полиномами по ведущей х-переменной. Необязательная always-опция позволяет представлять каждое заменяемое П-подвыражение W-выражения в виде П-∑+V. Аналогично рассмотренному выше случаю subs-функции результатом подстановки на основе asubs-процедуры не является вычисление и при необходимости выполнения полного вычисления результата подстановки требуется применение eval-функции, как это проиллюстрировано в нижеследующем фрагменте.

Наконец, по процедуре algsubs(a=b, V {, x|, x, <Опция>}) производится алгебраическая подстановка b-подвыражения вместо каждого вхождения a-подвыражения в V-выражение. В данном отношении algsubs-процедура является обобщением вышерассмотренной subsфункции, осуществляющей синтаксического характера подстановки. Расширенные возможности первой функции относительно второй хорошо иллюстрируют примеры нижеследующего фрагмента. Более того, в отличие от subs-функции, процедура algsubs выполняет подстановку в V-выражение рекурсивно, не делая подстановок внутри индексированных подвыражений. Между тем, она также перед подстановкой не производит раскрытия степеней и произведений, что требует в ряде случаев предварительного применения к V-выражению expand-функции.

В случае выполнения подстановок в W-выражение от нескольких ведущих переменных возможно появление неопределенностей, связанных с неоднозначностью толкования правила применения подстановки. Для устранения подобных ситуаций при проведении подстановок в W-выражение используются необязательные третий и четвертый аргументы algsubs-процедуры. Прежде всего, третий х-аргумент функции, кодируемый в виде списка, устанавливает порядок ведущих переменных, определяющий сам режим подстановки. При отсутствии данного аргумента порядок переменных устанавливается на основе правила подстановки, заданного первым фактическим аргументом функции. Совместно с третьим аргументом может использоваться и опция, допускающая два значения: remainder (по умолчанию) и exact, определяющие режим выполнения подстановки в обрабатываемое W-выражение. В частности, при отсутствии четвертого аргумента в результате подстановки в рациональное W-выражение вычисляется обобщенный остаток. Тогда как по exact-опции в случае, если в правиле подстановки a=b левая ее a-часть является суммой термов, то подстановка производится только тогда, когда a-часть является точным делителем замещаемого ею подвыражения в W-выражении.

В отличие от вышерассмотренных функции subs и процедуры asubs, результатом подстановки на основе algsubs-процедуры является вычисление, поэтому не требуется последующего применения eval-функции для обеспечения полного вычисления результата подстановки. Данное свойство функции позволяет успешно использовать ее для обеспечения символьно-численных вычислений, включающих как символьные преобразования, так и численные вычисления. Рассмотренные функциональные средства Subsгруппы играют весьма важную роль во многих задачах символьной обработки алгебраических выражений в среде Maple

В отличие от рассмотренных средств Subs-группы, обеспечивающих, в первую очередь, символьную обработку выражений на основе синтаксически-алгебраических подстановок, applyop-процедура, имеющая следующий простой формат кодирования: applyop(F, <Операнды>, W {, <F-аргументы>})

обеспечивает выборочное применение F-функции к указанным вторым фактическим аргументом applyop-процедуры операндам W-выражения с возможностью передачи ей фактических F-аргументов, определяемых необязательным четвертым аргументом. При указании в качестве второго фактического аргумента целочисленного р-выражения имеет место соотношение: applyop(F, p, W) = subsop(p=F(op(p,W)), W), которое сохраняет силу и в случае списка целочисленных выражений в качестве второго фактического аргумента applyop-поцедуры, позволяя производить выборочную F-обработку подвыражений W-выражения. В случае указания в качестве второго фактического аргумента applyop-процедуры множества целочисленных выражений F-обработке одновременно подвергаются соответствующие элементам множества операнды W-выражения. Необязательный четвертый аргумент applyop-процедуры позволяет передавать F-функции дополнительные фактические аргументы в порядке их кодирования. Данная функция позволяет выборочно обрабытывать операнды выражений.

С детализирующими замечаниями по всем представленным выше средствам подстановок можно ознакомиться в наших книгах [9-14]. Следующий сводный фрагмент иллюстрирует примеры применения рассмотренных средств обеспечения подстановок различных типов:

С учетом сказанного особых пояснений примеры фрагмента не требуют. Вместе с тем, наряду с рассмотренными функциями поддержки подстановок в целом ряде случаев эффективно использовать две ранее рассмотренные функции numboccur(V,h) и has(V,h), возвращающие число вхождений и сам факт вхождения {true|false} h-подвыражения в V-выражение соответственно. В качестве примера ниже приводится PSubs-процедура, существенно использующая первую из указанных функций Maple-языка. Слелующий фрагмент представляет исходный текст процедуры PSubs и примеры ее применения.

В качестве первого аргумента PSubs-процедуры выступает последовательность, элементами которой могут быть отдельные уравнения (правила подстановок) либо их множества/списки. Вторым аргументом процедуры выступает собственно само обрабатываемое выражение. Процедура возвращает результат последовательного применения заданных первым фактическим аргументом правил в выражение, заданное ее вторым фактическим аргументом. Одновременно выводится информация по применению каждого из правил подстановки. Читателю рекомендуется разобраться в организации процедуры. С целью лучшего усвоения принципов и особенностей выполнения вышерассмотренных средств, имеющих важные приложения, читателю рекомендуется провести с ними определенную наработку. В частности, в качестве весьма полезного упражнения читателю рекомендуется в терминах алгебраических правил подстановок запрограммировать в среде Maple-языка хорошо известные абстрактные модели вычислителей, например, машину Тьюринга (последовательная модель вычислений) и классические однородные структуры (параллельная модель вычислений) [1-3,36,40,92-96,98,100-102].

Учитывая важность различного рода подстановок при работе с символьными и строчными выражениями – одними из основных составляющих символьных вычислений и обработки – нами был определен целый ряд средств данного типа, ориентированных на различные случаи приложений [41,103,108,109]. В частности, процедура Sub_st(E, S, R {, `insensitive`}) возвращает результат подстановки правых частей уравнений, определенных первым фактическим аргументом Е, в строку или символ, указанный вторым аргументом S, вместо всех вхождений в нее левых частей уравнений Е. При этом, обработке подвергаются и пересекающиеся вхождения левых частей уравнений подстановок. Более того, тип возвращаемого результата соответствует типу второго аргумента S.

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

Правила подстановок Е задаются списком уравнений вида [Y1 = X1, Y2 = X2, …, Yn = Xn]; где для обеих частей уравнений предполагаются выражения типов {string, symbol}. При этом, алгоритм применения системы подстановок Е состоит в следующем: первая подстановка Е применяется к S до ее полного исчерпания в S, затем аналогичная операция проделывается со второй подстановкой из Е, и так далее до полного исчерпания всех подстановок из Е.

При кодировании четвертого дополнительного аргумента insensitive процедура Sub_st поддерживает регистро-независимый, в противном случае выполняется регистро-зависимый поиск вхождений левых частей подстановок. Наконец, через третий фактический аргумент R возвращается следующее значение: (1) true, если обработка S была завершена успешно, (2) результат обработки S до ситуации обнаружения подстановки, ведущей к бесконечному процессу (циклическая работа). Выше представлен фрагмент с исходным текстом процедуры Sub_st и результатами ее применения.

Наряду с целым рядом средств, обеспечивающих разнообразную обработку символьных и строчных выражений, наша библиотека [41,103] содержит и средства поддержки ряда полезных в практическом отношении подстановок. Читатель и сам может запрограммировать требуемые для своих конкретных приложений интересные средства, используемые многократно.

В определенной мере к средствам, обеспечивающим подстановки в выражения, примыкает и специальное use-предложение языка, имеющее формат кодирования: use <ПВ> in <ПП> end use

где ПВ – последовательность выражений типа {`=`, equation} и ПП – последовательность предложений Maple (тело use-предложения). ПВ определяет последовательность связывающих форм. В простейшем виде связывающая форма представляет собой уравнение (точнее, правило подстановки), чья левая сторона представляет имя, тогда как правой стороной уравнения может быть любое выражение языка, но не их последовательность. Другие виды связывающих форм определяются в терминах эквациональных связывающих форм. В качестве связывающих форм могут выступать выражения выбора члена модуля; связывающая форма вида М:- e эквивалентна эквациональной связывающей форме e = М:- e. Наконец, в качестве связывающей формы может выступать модульное выражение либо его имя. Использование модуля М в качестве связывающей формы эквивалентно определению уравнения e = М:- e для всех экспортов e модуля М. Предложение use отличается от всех других предложений Maple-языка тем, что оно разрешается в течение автоматического упрощения, а не в процессе вычислений. Предложение use не может быть вычислено.

Предложение use вызывает синтаксическое преобразование его тела согласно подстановкам, указанным в последовательности связывающих форм. Однако, оно в отличие от простых подстановок производит их в соответствии со статическими правилами просмотра Maple-языка. Каждое use-предложение вводит новый контур связывания, в пределах которого в течение упрощения имена левых частей каждого из уравнений связывания заменяются соответствую-ими выражениями правых частей уравнений. Тело useпредложения "перезаписывается", выполняя указанные замены.

Каждое вхождение связующего имени (левая часть) заменяется соответствующим ему выражением (правая часть) всюду по телу use-предложения. Когда тело use-предложения вычисляется, значение связующего имени вычисляется один раз для каждого его вхождения. Это означает, что в то время как само use-предложение не налагает никаких ограничений в процессе вычисления, следует проявлять внимательность в случае, когда правые части уравнений связывания могут выполнять важные вычисления. Правые части связывающих форм не вычисляются при обработке use-предложения. Детальнее с useпредложением можно ознакомиться по конструкции ?use, здесь же мы представим примеры, иллюстрирующие применение use-предложения в различных ситуациях:

Из примеров фрагмента следует, что use-предложение в процедурах и модулях игнорирует замены локальных, глобальных и экспортируемых переменных, возвращая свое тело лишь упрощенным без выполнения тех замен, левые части которых определяют имена указанного типа переменных. Более того, use-предложение не производит прямых замен, в частности, бинарных инфиксных операторов (например, `+` и `*`) или унарных префиксных или постфиксных операторов, как это иллюстрирует 8-й пример фрагмента. Тогда как такие операторы можно заменять, если правые части связывающей формы определяют процедуры или модули, как это иллюстрирует 9-й пример фрагмента. По use-предложению можно заменять такие операторы как: `+`, `*`, `-`, `/`, `^`, `!`, `and`, `or`, `not`, `=`, `<>`, `<`, `<=`.

Представленная выше процедура Use(P, x=x1, y=y1, …) в ряде случаев оказывается неплохим дополнением use-предложению, обеспечивая подстановки правых частей уравнений, определяемых фактическими аргументами, начиная со второго, вместо вхождений в выражение Р соответствующих им левых частей. При этом, в качестве первого аргумента Р может выступать любое выражение, кроме модулей; в противном случае вызов процедуры возвращает исходное выражение с выводом соответствующего предупреждения. На остальных выражениях Р вызов процедуры Use(P, x = x1, y = y1,…) во многом подобен результатам применения use-предложения, тогда как имеется и целый ряд особенностей. Например, Use-процедура позволяет делать прямые замены вышеуказанных операторов, обрабатывает особые и ошибочные ситуации и др. Предыдущий фрагмент представляет исходный текст процедуры Use и примеры ее применения. При этом, если необходимо произвести обработку Use-процедурой последовательности выражений или предложений, то их можно обрамлять процедурой, как иллюстрирует последний пример фрагмента. В ряде приложений Use-процедура предпочтительнее use-предложения. Наша Библиотека [41,103,109] представляет целый ряд достаточно полезных средств для обеспечения различного рода как символьных, так и алгебраических подстановок, ряд из которых довольно неплохо дополняют стандартные средства подобного типа. Многие из них используются и другими средствами Библиотеки, в ряде случаев существенно упрощая программирование и делая реализуемые ими алгоритмы более програчными.

5.4. Средства Maple-языка для обработки алгебраических выражений

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

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

simplify(<Выражение> {, <Тип упрощения>} {, assume = <Свойство>})

и производящей упрощение заданного своим первым фактическим аргументом выражения путем применения к нему специальных процедур упрощения. Если процедура содержит единственный аргумент-выражение, то производится анализ выражения на предмет вхождения в него вызовов функций, квадратных корней, радикалов и степеней. После этого к выражению применяются подходящие упрощающие процедуры, включающие функции: Бесселя, Гамма, Ламберта, e^x , ln, √x, тригонометрические, гиперболические и др., т.е. производится возможное упрощение исходного выражения по всему спектру возможностей функции. Третий необязательный фактический аргумент функции позволяет приписывать всем переменным упрощаемого выражения определенные свойства, которые будут приписаны переменным упрощенного выражения, либо определять параметры, управляющие применением правил упрощения. Второй аргумент функции также является необязательным и определяет принцип упрощения исходного выражения, определяемого первым аргументом, согласно специальным типам упрощающих правил. В качестве второго аргумента simplify-процедуры могут выступать отдельный идентификатор, список или множество идентификаторов, определяющих специальные типы упрощения исходного выражения. В качестве таких идентификаторов допускаются следующие, определяемые в табл. 11:

Таблица 11

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

> SV:= 6*z*y^2 + 6*z^4*y^3 - 18*z^2*y + 112 + 53*z^2 + 14*z*y - 306/5*y^2 + 3*x*z - 3*x*y + 18*z^4 + 8*z^3*y - 4*z^2*y^2 - 8*z*y^3 + 4*y^4:

> simplify(SV, {x*z - y^2=x, x*y^2 + z^2=z, (z+y)^2=x, (x+y)^2=z}, {x,y,z}); ⇒ 112 + 74 x > Sideral:= {sin(x)^2 + cos(x)^2 = 1, 2*sin(x)*cos(x) = 1 - (cos(x) - sin(x))}:

> Expression:= sin(x)^3 - 3*sin(x)^2*cos(x) - cos(x)^3 - sin(x)*cos(x) + sin(x)^2 + 2*cos(x):

> H1:= BesselJ: H2:= BesselY: simplify(Expression, 'Sideral'); ⇒ cos(x)3

> simplify(Pi*y*(H1(x + 1, y)*H2(x, y) - H1(x,y)*H2(x + 1, y)), 'wronskian'); ⇒ 2

> simplify(cos(x)*diff(sin(x), x) - sin(x)*diff(cos(x), x), 'wronskian'); ⇒ sin(x)² + cos(x)²

За более детальным описанием и особенностями применения simplify-процедуры можно обращаться к справке по пакету либо к нашей книге [12], принимая во внимание, что и релиз накладывает свои особенности. Вместе с тем, представленной информации вполне достаточно для проведения многих важных упрощающих процедур над довольно широким классом алгебраических и числовых Maple-выражений различного типа.

К задаче упрощения алгебраических W-выражений непосредственно относится и процедура fnormal(W {, D|, D, ε}), возвращающая для алгебраического выражения, определяемого первым фактическим W-аргументом, эквивалентное ему W*-выражение в том отношении, что все входящие в него числовые значения float-типа, меньшие ε-величины, определяемой третьим необязательным аргументом функции, полагаются нулевыми. При этом, все float-значения W-выражения вычисляются с D-точностью, определяемой вторым необязательным фактическим аргументом процедуры. По умолчанию для аргументов D и ε процедуры полагаются соответственно значения глобальной Digits-переменной и Float(1, -D + 2)-значение. В качестве первого фактического W-аргумента процедуры могут выступать как отдельное алгебраическое выражение, так и список, множество, отношение, ряд или диапазон такого типа выражений. Следующий весьма простой фрагмент иллюстрирует применение fnormal-процедуры:

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

По процедуре radsimp(V {, ratdenom}) производится упрощение V-выражения, содержащего радикалы; кодирование необязательного второго аргумента функции определяет необходимость избавления знаменателя выражения от радикалов, например:

> [radsimp(3^(1/2) + 2/(2 + sqrt(3))), radsimp(3^(1/2) + 2/(2 + sqrt(3)), 'ratdenom')];

^  ² 2 + ^{3 +} 3⁵ , −(2 3 + 5 () −2 + 3 )^ _ 

> [radsimp(sqrt(x) + a/(b + sqrt(x))), radsimp(sqrt(x) + a/(b + sqrt(x)), 'ratdenom')];

 x bb + + xx + a, − ( x b + −x + b2 + a)x(b − x ) 

В определенной мере к simplify-процедуре примыкает и функция convert(W, <Форма>), обеспечивающая конвертацию W-выражения из одной в другую форму, определяемую вторым аргументом функции. Некоторые ее дополнительные возможности по конвертации выражений будут рассмотрены ниже. Функция convert может использоваться в сочетании как с рассмотренной simplify-процедурой, так и с рассматриваемыми ниже другими средствами Maple-языка для упрощения различного рода выражений.

По функции с форматом кодирования expand(<Выражение> {, V1,V2,...,Vn}) производится раскрытие указанного ее первым фактическим аргументом выражения на суммы и термы некоторых других типов. Первой попыткой функции является раскрытие произведений в суммы, что характерно, в первую очередь, для полиномов; для полиномиальных дробей такому раскрытию подвергаются только их числители. Для многих математических функций (sin, cos, tan, sinh, cosh, tanh, det, erf, exp, factorial, GAMMA, ln, int, max, min, Psi, binomial, sum, product, limit, bernoulli, euler, signum, abs, кусочно-определенных и др.) expand-функция обеспечивает стандартные формы раскрытия. При необходимости запрета на раскрытие каких-либо Vk-подвыражений раскрываемого по expand-функции выражения следует кодировать их в качестве ее необязательного второго аргумента – последовательности подвыражений. При необходимости запрета на раскрытие всех входящих в раскрываемое выражение функций используется frontend-функция в конструкции вида frontend(expand, [Выражение]). Следующий фрагмент иллюстрирует вышесказанное:

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

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

expand{off|on}({Id_1, Id_2, ..., Id_n})

возвращающие NULL-значения и позволяющие соответственно {запрещать|разрешать} раскрытие функций, указанных последовательностью их идентификаторов (Id_k) в качестве фактического аргумента функции. В случае же вызова функции expand{off|on}() описанное действие по санкционированию раскрытия функций expand-функцией распространяется на все функции текущего сеанса, исключая пользовательские функции.

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

Данный фрагмент иллюстрирует также remember-свойство expand-функции, состоящее в том, что раз возвратив разложение выражения, функция будет помнить его, даже если наложен запрет на разложение входящих в него функций пакета. В значительной мере это весьма полезное свойство, однако оно в определенной мере не согласуется с функцией expandoff, запрещающей разложение заданных функций Maple-языка.

При использовании {expandoff|expandon}-функции следует иметь в виду, что в текущем сеансе работы с ядром она имеет однократное действие (причины этого лежат в свойстве remember функции expand) и попытки ее повторного использования или инициирующих ее конструкций приводят к ошибочной ситуации, как показано в следующем фрагменте. Ситуация разрешается, в частности, после выполнения restart-предложения.

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

Наконец, пассивная Expand(v)-функция представляет собой шаблон expand-функции, используемый в конъюнкции с evala-функцией или в mod-конструкциях. По конструкции вида evala(Expand(v)) производится раскрытие произведений в произвольном v-выражении, которое может включать алгебраические числа и/или RootOf-процедуры. Тогда как по конструкции Expand(v) (mod p) производится раскрытие произведений над целыми по (mod p) и v-выражение может содержать вызовы RootOf-процедур. Например:

> Expand((57*x + 3)^2*(x^2 - 2*x + 52)) mod 5; ⇒ 4 x⁴ + 4 x³ + 3 x² + x + 3

> evala(Expand(RootOf(x^2 - 3*x - 10)^2)); ⇒ 10 + 3 RootOf(_Z² - 3 _Z - 10)

Обратной к expand является factor(V{, F})-процедура, возвращающая результат факторизации V-выражения полиномиального типа с целыми, рациональными, комплексными или алгебраическими числовыми коэффициентами. При этом, если V – отношение полиномов, то производится факторизация отдельно для числителя и знаменателя. Второй необязательный F-аргумент функции определяет тип числового поля, над которым должна производиться факторизация; по умолчанию выбирается поле, определяемое типом коэффициентов полинома. При значениях для F-аргумента real или complex типа производится соответственно float- или complex-факторизация. В этом случае в качестве V-выражения должен выступать полином от одной переменной или их отношение. Если в качестве факторизуемого V-выражения выступает список, множество, диапазон выражений, ряд, отношение либо функция, то факторизация применяется рекурсивно к его компонентам. Следующий прозрачный фрагмент иллюстрирует некоторые варианты применения factor-процедуры для факторизации выражений:

Если в качестве значения F-аргумента выступают RootOf-процедура, список либо множество RootOf-процедур, радикал, их список либо множество, то факторизация производится над соответствующим числовым алгебраическим полем.

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

n ^k[j]

[G, [[M[1], k[1]], [M[2], k[2]], ... [M[n], k[n]]]] ; V = G * ∏ _M[j] j 1= где M[j] и k[j] – соответственно фактор (сомножитель) и его кратность. Данная структура достаточно удобна при использовании результатов факторизации в задачах программирования, т.к. позволяет легко выделять составляющие ее компоненты. Сказанное о втором необязательном F-аргументе factor-процедуры переносится и на factors-процедуру. Пассивная функция Factors(V{, F}) представляет собой шаблон factors-процедуры, используемый в конъюнкции с evala-функцией либо в mod-конструкции аналогично тому, как это было описано для Factor-функции с очевидными изменениями. Следующий фрагмент иллюстрирует использование рассмотренных средств факторизации:

В приведенном фрагменте полиномиальные выражения Р1 и Р2 соответствуют предыдущему фрагменту,а возвращаемый factors-процедурой результат не управляется предопределенной Digits-переменной окружения пакета.

С еще большим основанием обратной к expand-функции можно назвать combine-процедуру, имеющую формат кодирования, подобный simplify-процедуре, а именно: combine(<Выражение> {, <Тип объединения>} {, <Параметры>})

Процедура использует правила, объединяющие термы сумм, произведений и степеней в единое целое, упрощая исходное выражение. При этом, производится приведение подобных термов. Второй необязательный аргумент процедуры определяет тип объединения термов выражения, подобно случаю simplify-процедуры. В качестве первого аргумента combine-процедуры могут выступать списки, множества и отношения выражений, к элементам которых функция применяется рекурсивно. Третий необязательный аргумент функции определяет специфические параметры для конкретного типа объединения, указаного вторым аргументом процедуры. Следует иметь в виду, что для многих функций Maple-языка пакета expand и combine являются взаимно-обратными.

В качестве второго фактического аргумента combine-процедуры могут выступать отдельный идентификатор, список или множество идентификаторов, определяющих специальные типы объединения термов исходного выражения. В качестве таких идентификаторов допускаются следующие, определяемые в табл. 12.

Таблица 12

Смысл и назначение каждого из представленных в табл. 12 значений для второго фактического аргумента combine-процедуры достаточно прозрачны и проиллюстрированы в следующем фрагменте, однако по отдельным необходимы пояснения [8-14,39].

Для arctan-аргумента процедуры symbolic-параметр задает необходимость проведения объединения combine-процедурой термов, даже если процедура не устанавливает условия для объединения; как правило, это требуется в случае символьных аргументов функций arctan. Для ln-аргумента допускается использование symbolic-параметра, имеющего смысл предыдущего замечания, и параметра {integer|anything}, определяющего тип {целый|любой} для коэффициентов логарифмических термов. При этом, кодирование этих параметров производится в порядке: {integer|anything}, symbolic. Для radical-аргумента допускается использование symbolic-параметра, полагающего подрадикальные термы неопределенного знака действительными и положительными.

Следует отметить, что особого смысла использование piecewise-аргумента для combineпроцедуры не имеет, ибо во многих случаях уже простейшие выражения, содержащие кусочно-определенные функции, возвращаются без изменений либо с минимальными упрощениями. Детально данный вопрос рассматривается в наших книгах [10-11,14].

По вызову combine(V, ln {, t {, symbolic}}) производится группировка логарифмических термов V-выражения; при этом, необязательные третий t-аргумент процедуры определяет тип коэффициентов в логарифмических термах выражения, тогда как четвертый - необходимость проведения группировки в символьном виде. В качестве как самостоятельного средства упрощения (преобразования) выражений, так и в совокупности с combineпроцедурой может выступать и simplify(V, power {, symbolic})-процедура, обеспечивающая упрощение V-выражения, содержащего степени, экспоненты или логарифмы и их совокупности. Следующий простой фрагмент хорошо иллюстрирует вышесказанное:

Завершить данный пункт целесообразно важной процедурой collect, имеющей формат: collect(<Выражение>, <Переменная> {, <Форма> {, Proc}})

и рассматривающей выражение, заданное ее первым фактическим аргументом, в качестве обобщенного полинома по определенной вторым аргументом ведущей переменной

(списком или множеством переменных; в качестве переменных допускаются и идентификаторы функций). Согласно данному предположению collect-процедура возвращает результат приведения всех коэффициентов при одинаковых рациональных степенях ведущих переменных. При этом, сортировки термов не производится и в случае такой необходимости используется ранее рассмотренная sort-функция Maple-языка.

Третий необязательный аргумент определяет форму приведенного выражения, допуская два значения recursive (по умолчанию) и distributed. В первом случае производится рекурсивное приведение выражения относительно каждой из ведущих переменных {x1, x2, ..., xn}, во втором - относительно термов x1^p *x2^q *...*xn^k . Наконец, четвертый необязательный аргумент collect-процедуры позволяет задавать процедуру (Proc), применяемую к коэффициентам приведенного выражения. В качестве такой процедуры наиболее употребительны такие как simplify, factor и sort, рассмотренные выше. В качестве основных приложений collect-процедуры отметим следующие.

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

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

В данном пункте был рассмотрен ряд базовых средств, обеспечивающих важные задачи по упрощению символьных выражений. Среди них следует еще раз акцентировать ваше внимание на таких часто используемых средствах как: convert, simplify, factor, combine, collect, map, expand. При этом, следует иметь в виду, что в задачах упрощения (а в более жестком понимании и канонизации) выражений используются также и другие функции Maple-языка, имеющие иную основную направленность или более узкую ориентацию, например, на задачи полиномиальной арифметики, представленные в языке достаточно хорошо. Однако и задачу упрощения выражений следует понимать в существенно более широком смысле, как представление выражений в наиболее приемлемом для конкретных приложений виде. В следующем пункте настоящего раздела рассматриваются базовые средства, обеспечивающие символьные преобразования выражений и их алгебраическую обработку в целом.

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

Прежде всего, задачи символьной обработки предполагают проведение определенных видов анализа символьных выражений: определение типа выражения, определение функциональной зависимости и др. Из данных средств можно отметить наиболее важные на начальной стадии освоения средств символьной обработки. Рассмотренные ранее функции nops и op многофункциональны и с успехом могут использоваться для общего анализа внутренней структуры ряда типов объектов, тогда как по функциям typematch, type и whattype-процедуре и можно получать тип анализируемого объекта.

Для выявления факта зависимости алгебраического выражения от переменных служит логическая процедура depends(<Выражение>, <Переменные>), возвращающая true-значение, если указанные вторым аргументом ведущие переменные (отдельная, список либо множество) входят в заданное первым фактическим аргументом выражение, и false-значение в противном случае. При этом, переменная полагается ведущей, если она не связана внутренним соотношением (переменная индексная, суммирования, интегрирования, произведения и т.п.). В качестве как первого, так и второго фактических аргументов depends-процедуры могут выступать список или множество соответственно выражений и ведущих переменных. Функция возвращает true-значение, если обнаруживает указанного типа зависимость по меньшей мере для одной из пар <выражение, переменная>. Следующий фрагмент иллюстрирует применение depends-процедуры для установления факта наличия зависимости выражения от заданных переменных:

> depends([ln(x) + sin(y), ln(t + sqrt(z)), sqrt(Art(x) + Kr(z))], {x, z}); ⇒ true

> [depends(ln(x) + sin(y), {x, z}), depends(ln(t + sqrt(z)), {z, h})]; ⇒ [true, true]

> [depends(F(x)$x = a..b, x), depends(F(x)$x = a..b, {b, h})]; ⇒ [true, true]

> [depends(int(GS(y), y = a..b), y), depends(int(GS(y), y = a..b), b)]; ⇒ [false, true] > [depends(M[n]*x, n), depends(M[n]*x, x), depends(diff(H(y), y), y)]; ⇒ [true, true, true] > F:= x -> (cosh(x)^2 + sinh(x)^2)*(cos(x)^2 + sin(x)^2)/(2*cosh(x)^2 - 1):

> [depends(F(x), x), depends(simplify(F(x)), x), simplify(F(x))]; ⇒ [true, false, 1]

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

> depends(F(x)$x = 1 .. 64, x);

Error, invalid input: depends expects its 2nd argument, x, to be of type {name, list(name), set(name)}, but received F(2)

Для тестирования произвольного V-выражения на предмет вхождения в него заданного элементарного H-подвыражения можно использовать Etest-процедуру, созданную на основе рассмотренных выше функций {op, nops} и процедуры charfcn:

Данная процедура возвращает true-значение в случае установления факта вхождения элементарного H-терма в качестве подвыражения в V-выражение, и false-значение в противном случае, где под элементарным будем полагать G-терм, для которого имеет место определяющее соотношение nops({op(G)}) ⇒ 1. Предыдущий фрагмент представляет исходный текст Etest-процедуры с примерами ее конкретного вызова. Процедура Etest(V, H, R) тестирует наличие факта вхождения в V-выражение элементарного H-терма и через третий фактический R-аргумент возвращает множество всех элементарных термов тестируемого V-выражения без учета их кратности. Процедура может представить определенный практический интерес и читателю рекомендуется в качестве полезного упражнения рассмотреть ее организацию.

Функция indets(W) возвращает множество, содержащее все независимые переменные алгебраического W-выражения, включая такие константы как {false, gamma, infinity, true, Pi, Catalan, FAIL}. Между тем, во многих случаях требуется найти все именно независимые переменные алгебраического W-выражения, т.е. X-переменные, удовлетворяющие определяющему соотношению type(eval(X), 'symbol'); ⇒ true. Процедура Indets [103,109] решает данную задачу. Вызов процедуры Indets(W) возвращает множество, содержащее все независимые переменные алгебраического W-выражения, удовлетворяющие вышеупомянутому условию, например:

В отличие от предыдущей процедуры вызов процедуры indetval(A) [42,103] возвращает множество всех возможных неопределенных символов произвольного Maple-выражения А, базируясь на его операндах всех уровней. В случае кодирования в качестве второго необязательного аргумента t допустимого Maple-типа вызов процедуры indetval(A, t) возвращает операнды А-выражения, имебщие t-тип. Приведенные ниже примеры хорошо иллюстрируют сказанное:

> k:= 64: t:= table([x = 64, y = 59, z = 39]): indetval(k), indetval(t), indetval(t, 'integer');

{}, {x, y, z}, {39, 59, 64}

> type(MkDir, 'procedure'), indetval(MkDir);

true, {f, F, K, d, u, g, r, v, t, z, k, L, h, cd, s, omega, Lambda}

> indetval(Pi*cos(x) +Catalan*sin(y) - 2*exp(1)*gamma*z - sqrt(6)*ln(14)/(t+h) + G*S*V*Art*Kr);

{S, V, t, x, y, z, G, h, Art, Kr}

> Indets(Pi*cos(x) + Catalan*sin(y) - 2*exp(1)*gamma*z - sqrt(6)*ln(14)/(t+h) + G*S*V*Art*Kr);

{S, V, t, x, y, z, G, h, Art, Kr}

> indets(MkDir), Indets(MkDir), indets(t), Indets(t), indetval(t), indetval(t, 'integer');

{MkDir}, {MkDir}, {t}, {t}, {x, y, z}, {39, 59, 64}

> indets(nmmlft), Indets(nmmlft), indetval(nmmlft), indetval(nmmlft, 'procedure');

{nmmlft}, {nmmlft}, {f, F, d, c, t, k, h, a, b, p, file}, {min, max}

По функции normal(V {, extended}) производится упрощение рационального V-выражения и приведение его к нормальной форме, суть которой состоит в приведении к общему знаменателю на всех уровнях и сокращению числителя и знаменателя на общие множители. Вместе с тем, факторизации выражения не производится и выделяются только тривиальные сомножители. Для получения канонической нормальной формы следует использовать factor(normal(V))-конструкцию. В качестве V-выражения могут выступать ряд, список, множество, диапазон, уравнение, отношение или функция, нормализация которых производится рекурсивно относительно их элементов. В случае кодирования необязательного extended-аргумента в числителе и знаменателе полиномы остаются раскрытыми. Следующий простой фрагмент иллюстрирует вышесказанное: