Plotting error empty plot maple

Первые три примера фрагмента представляют простые процедуры AG, SV и MV, назначение первой из которых легко усматривается из ее определения, а две другие возвращают соответственно результат тестирования и список номеров позиций вхождения х-элемента в заданный L-список. Все три процедуры возвращают результат стандарным способом через последнее предложение тела процедуры. Остальные примеры фрагмента иллюстрируют возврат результата процедуры RETURN-функцией либо return-предложением.

Процедура ММ возвращает список с номером позиции первого вхождения х-элемента в L-спи- сок и сам элемент, в противном случае возвращается false-значение. Процедура для возврата результата вызова использует как стандартный метод, так и функцию RETURN. При этом, рекомендуется обратить внимание на реализацию процедуры однострочным экстракодом. Процедура ТР возвращает результат анализа получаемых при ее вызове фактических аргументов в разрезе числовых и нечисловых с идентификацией количества аргументов обоих типов. Процедура VS возвращает таблицу, первый столбец которой содержит передаваемые процедуре вычисленные фактические аргументы, а второй — их типы. Одним из достоинств использования функции RETURN является возможность эффективного возврата значений локальных переменных из целого ряда важных вычислительных конструкций, а также обеспечение гибкой возможности избирательности возврата результатов вызова пользовательских процедур. Тогда как return-предложение имеет существенно меньшие выразительные возможности по представлению вычислительных алгоритмов в среде пакета.

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

В общем случае функция RETURN(V1,V2, …, Vn), где в качестве фактических аргументов могут выступать произвольные Maple-выражения, предварительно вычисляемые, может не только возвращать конкретные результаты вычисления Vk-выражений, связанных со спецификой тела процедуры, но и возвращать в определенных условиях вызов процедуры невычислен— ным. Для этих целей, как правило, используется конструкция вида RETURN(‘Proc(args)’), где Proc — имя (идентификатор) процедуры. Библиотечные процедуры Maple в случае некорректного либо прерванного вызова возвращают FAIL-значение, если нецелесообразно возвращать вызов процедуры невычисленным. Следующий простой фрагмент иллюстрирует сказанное:

> LO:= proc() local k; for k to nargs do if whattype(args[k]) <> ‘float’ then return ‘LO(args)’ end if end do end proc: LO(64, 59, 39.37, 19.81, 19.83, 10, 17, G, S);

LO(64, 59, 39.37, 19.81, 19.83, 10, 17, G, S)

> [sqrt(10), sin(17), ln(gamma), exp(Pi)];

[10, sin(17), ln(γ), eπ ]

Вданном фрагменте LO-процедура в случае обнаружения среди переданных ей фактических аргументов выражения типа, отличного от float, сразу же осуществляет выход по return— предложению с возвращением своего вызова невычисленным. Тогда как второй пример фрагмента иллюстрирует возврат невычисленных вызовов базовых функций Maple-языка.

Вцелом ряде случаев возвращать результат вызова процедуры представляется весьма удобным через ее формальный h-аргумент, который кодируется в заголовке процедуры в последовательности ее формальных аргументов в виде h{::evaln}. Соответствующие же им фактические аргументы кодируются в виде {‘H’|H}, т.е. процедуре сообщается, что ей передается не значение соответствующего ему фактического аргумента, а его идентификатор. В этом случае в теле процедуры производится присвоение данному фактическому аргументу-иденти-

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

G := proc (L::list, x::evaln, y::evaln, z::evaln) local a, b, c, k;

`&ma`(a, b, c, [ ]), seq(`if`(type(L[k], ‘float’), assign(‘a’ = [op(a), L[k]]), `if`( type(L[k], ‘integer ‘), assign(‘b’ = [op(b), L[k]]),

`if`(type(L[k], ‘fraction ‘), assign(‘c’ = [op(c), L[k]]), NULL ))),

k = 1 .. nops(L)), assign(x = a, y = b, z = c), evalf(sqrt(`+`(op(L))))

end proc

> G([2006, 64, 10/17, 19.42, 59/1947, 350, 65.0 ,16.10], a, v, z), a, v, z;

10 1 50.21094042, [19.42, 65.0, 16.10], [2006, 64, 350], 17, 33

G1 := proc (L::list, x::evaln, y::evaln, z::evaln) local a, b, c, d, k;

`&ma`(a, b, c, d, [ ]), seq(`if`(type(L[k], ‘float’), assign(‘a’ = [op(a), L[k]]), `if`(type(L[k], ‘integer ‘), assign(‘b’ = [op(b), L[k]]), `if`(

type(L[k], ‘fraction ‘), assign(‘c’ = [op(c), L[k]]),

`if`(4 < nargs, assign(‘d’ = [op(d ), L[k]]), NULL )))), k = 1 .. nops(L)), assign(x = a, y = b, z = c), evalf(sqrt(`+`(op(L)))),

`if`(4 < nargs, assign(args[5] = d ), NULL ) end proc

> G1([2006, 64, 10/17, 19.42, A, 59/1947, 350, 65.0, V, 16.10, Z], a, v, z, ‘h’), a, v, z, h;

Первый пример фрагмента представляет G-процедуру, допускающую при своем вызове четыре фактических аргумента, из которых три последних имеют evaln-тип и через которые передаются списки фактических аргументов, имеющих типы float, integer и fraction соответственно. Тогда как в качестве основного возврата процедуры является результат вычисления корня квадратного из суммы фактических аргументов, переданных процедуре при ее вызове. Пример вызова процедуры иллюстрирует сказанное. Второй пример фрагмента представляет G1-процедуру, являющуюся модификацией предыдущей процедуры и допускающей при своем вызове более четырех фактических аргумента, из которых четыре первых аналогичны случаю процедуры G, тогда как через пятый необязательный аргумент передается список типов фактических аргументов процедуры, отличных от типов {float, integer, fraction}. Тогда как основной возврат процедуры аналогичен случаю G-процедуры. Пример вызова процедуры иллюстрирует сказанное. В обоих процедурах рекомендуется обратить внимание на использование нашего оператора/процедуры &ma [103], обеспечивающего присвоение одного и того же выражения последовательности переменных, и assign-процедуры для присвоения значений фактическим аргументам, через которые обеспечиваются вторичные возвраты.

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

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

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

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

………………………………………………………………….………

`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

Кодирование за заголовком процедуры типа не является в полном смысле слова типированием возвращаемого процедурой результата, а скорее утверждением (assertion). При установке kernelopts(assertlevel=2) производится проверка типа возвращаемого результата вызова процедуры. Если тип не соответствует утверждению, то возникает ошибочная ситуация с диагностикой «assertion failed: %1 expects its return value to be of type %2, but computed %3». При остальных установках assertlevel–опции утверждение игнорируется. Особого смысла в данном формате я не вижу и вот почему. Если необходимо типировать результат возврата, то намного удобнее и эффективнее это делать в самой процедуре на основе как реализуемого ею алгоритма, так и получаемых типов фактических аргументов. При этом, сохраняется непрерыв—

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

> P:= proc()::float; `+`(args)/nargs end proc: P(64, 59, 39, 10, 17, 44); 233/6 > kernelopts(assertlevel = 2): P(64, 59, 39, 10, 17, 44);

Error, (in P) assertion failed: P expects its return value to be of type float, but computed 233/6

> lasterror;

«assertion failed: %1 expects its return value to be of type %2, but computed %3»

> P1:= proc()::float; local conv; conv:= proc(a::anything, b::anything) if a = NULL then b else convert(b, a) end if end proc; conv(op(8, eval(procname)), `+`(args)/nargs) end proc;

P1 := proc ()::float; local conv;

conv := proc (a::anything , b::anything )

if a = NULL then b else convert(b, a) end if end proc ;

conv(op(8, eval(procname )), `+`(args)/nargs ) end proc

> P1(64, 59, 39, 10, 17, 44); 38.8333333300

Фрагмент содержит подпроцедуру conv, результат вызова которой обеспечивает конвертиро— вание возвращаемого процедурой Р1 выражения в тип, определенный после заголовка процедуры. Возможно, в некоторых случаях такой прием может оказаться полезным.

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

4.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-функции для временных оценок:

> t:= time( ): G:= sin(10.3^8!): t1:= time( ): printf(`%s%1.3f%s`,`Время вычисления выражения «sin(10.3^8!)» равно: `, t1 — t, ` сек.`);

Время вычисления выражения «sin(10.3^8!)» равно: 29.781 сек.

> Time(); [0.50, 0.0083]

Фрагмент включает пример простой 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 := proc (t::{float, integer }, x::anything , V::symbol, p::evaln) local h, z;

z := time( );

if traperror(timelimit(t, assign(h = V(x)))) = «time expired» then p := [evalf(time( ) − z, 6), ‘undefined ‘]; false

else p := [evalf(time( ) − z, 6), h ]; true end if

end proc

> G:= proc(n) local k; for k to n do k end do end proc:

В приведенном фрагменте 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, 3 and 7 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-функции, начиная с Maple 6. Детальнее с оформлением диагностических сообщений для ERROR-функции (error—предло— жения) можно ознакомиться в справке по пакету.

При этом, значения Vk-выражений из ERROR-функции (Msg для error—предложения) помещаются в глобальную lasterror-переменную пакета и доступны для последующей обработки возникшей процедурной ошибки, которая с точки зрения Maple-языка в общем случае может и не быть ошибочной, как это иллюстрирует следующий простой фрагмент:

> restart; lasterror; lasterror

> A:= proc() local k; `if`(type(nargs, ‘odd’), ERROR(“odd number of arguments”), `+`(args)) end proc: A(64, 59, 39, 10, 17, 44, 95, 2006); 2334

> A(64, 59, 39, 10, 17, 44, 2006);

Error, (in A) odd number of arguments

>lasterror; «odd number of arguments»

>if lasterror = “odd number of arguments” then `Introduce new arguments` end if;

Introduce new arguments

>proc(x, y) `if`(x > y, ERROR(“for args[1] & args[2]”, args[1] > args[2]), y/x) end proc(17, 10);

Error, (in unknown) for args[1] & args[2], 10 < 17

>proc(x,y) if x>y then error “for args[1]&args[2]”,args[1]>args[2] else y/x end if end proc(17,10);

Error, (in unknown) for args[1] & args[2], 10 < 17

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

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

> 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

Это же, в свою очередь, не позволяет обрабатывать такого типа ошибки средствами пакета. В свою очередь, другого типа недоработки пакета иначе как «чехардой» назвать и вовсе трудно. В частности, доступ к отсутствующему файлу или каталогу для релизов 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: …«. Серьезными причинами такие замены объяснить трудно. Указанные моменты потребовали очередной корректировки нашей Библиотеки [103], например, путем корректировке try-предложения:

try …..

………

catch «file or directory does not exist»: …

catch «file or directory, %1, does not exist»: …… (введено дополнительно) ……….

end try

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

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

> WM:= proc() local k; global V; for k to nargs do if whattype(args[k]) <> ‘float’ then error nargs, [args] end if end do: `End of WM-procedure` end proc: WM(6.4, 350, 10, 17); lasterror;

Error, (in WM) 4, [6.4, 350, 10, 17]

4, [6.4, 350, 10, 17]

> WM1:= proc() local k; global V; for k to nargs do if whattype(args[k]) <> ‘float’ then return nargs, [args] end if end do: `End of WM1-procedure` end proc: WM1(6.4, 350, 10, 17);

4, [6.4, 350, 10, 17]

> if whattype(%) = exprseq then WM1(op(evalf(lasterror[2]))) end if;

End of WM1-procedure

> if whattype(%%) = exprseq then WM1(op(evalf(%%[2]))) end if;

End of WM1-procedure

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

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

VK := proc () local k;

for k to nargs do

if whattype(args[k]) ≠ ‘float’ then

error «%-1 argument has type different from ‘float'» , k

end if end do ;

«Body of procedure» end proc

> VK(6.4, 5.9, 10.2, 3, 17);

Error, (in VK) 4th argument has type different from ‘float’

> lasterror; «%-1 argument has type different from ‘float'», 4

> VK(6.4, 10.2, 5.9, 3.9, 2.7, 17.7); «Body of procedure»

Процедура VK программно обрабатывает ситуацию получения аргумента некорректного типа на основе error-предложения с выводом соответствующей диагностики.

Особенности и полезные рекомендации по использованию функции ERROR (error—предло— жения) для организации дополнительных выходов из процедур достаточно детально представлены в наших книгах [12-14,39]. Здесь же мы лишь сделаем одно замечание относительно реализации функций RETURN, ERROR и предложений return, error. В настоящее время эти средства попарно функционально эквивалентны, однако синтаксис их использования при создании процедур и программных модулей различен, а именно. В пакете Maple 5 и ниже использовались встроенные функции RETURN, ERROR, что в силу их концепции позволяло использовать их в любой точке, подобно обычным функциям. Во многих случаях это представляется весьма удобным. Однако, начиная с Maple 6, пакет, одновременно допуская указанные функции и предложения, между тем, настоятельно рекомендует использовать все же последние, синтаксис которых существенно уже. Вероятно, возможен вариант исключения функций из последующих релизов, что создаст еще один аспект несовместимости релизов уже на уровне исходных текстов. Такой подход несколько настораживает и порождает два