Програмирование в Maxima

ФБГОУВПО «Мордовский Государственный педагогический институт им. М.Е.Евсевьева»

 

Физико-математический факультет

 

Кафедра информатики и вычислительной техники

 

 

 

 

 Реферат

По теме: «Программирование в Maxima» 

 

 

 

 

                         

 

 

 

 

 

 

                                                                                                                                                                                               

 

 

Выполнил: студент  группы МДМ-214

физико-математического факультета

Смолькина Юлия

Проверила: Кормилицына Т.В.

 

 

 

 

 

Саранск 2016

Введение

 

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

Исходный код Maxima может компилироваться на многих системах, включая Windows, Linux и MacOS X. На SourceForge доступны исходные коды и исполняемые файлы для Windows и Linux.

Maxima — потомок Macsyma, легендарой системы компьютерной алгебры, разработанной в начале 60-х в MIT . Это единственная основанная на Macsyma система, все еще публично доступная и имеющая активное сообщество пользователей благодаря своей открытости. Macsyma произвела в свое время переворот в компьютерной алгебре и оказала влияние на многие другие системы, в числе которых Maple и Mathematica.

Работу над Maxima вел Уильям Шелтер с 1982 года и до своей кончины в 2001 году. В 1998 году он получил разрешение на публикацию исходного кода под лицензией GPL. Выживание Maxima стало возможным только благодаря его усилиям и способностям, мы очень благодарны ему за уделенные проекту время и знания эксперта, которые поддерживали код DOE Macsyma актуальным и качественным. После его кончины была сформирована группа пользователей и разработчиков, ставящая своей целью донести Maxima до широкой аудитории.

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

 

 

 

 

 

 

1.     Программирование на встроенном макроязыке

 

1.1   Условные операторы

 

Основная форма условного оператора: if cond1 then expr1 else expr0. Если условие cond1 истинно, то выполняется выражение expr1,иначе — выполняется выражение expr2. Пакет Maxima позволяет использовать различные формы оператора if, например: if cond1 then expr1 elseif cond2 then expr2 elseif ...else expr0 Если выполняется условие cond1, то выполняется выражение expr1, иначе — проверяется условие cond2, и если оно истинно —выполняется выражение expr2, и т.д. Если ни одно из условий не является истинным — выполняется выражение expr0. Альтернативные выражения expr1,expr2,... ,exprk — произвольные выражения Maxima (в т.ч. вложенные операторы if).

         Условия— действительно или потенциально логические выражения, сводимые к значениям true или false. Способ интерпретации условий зависит от значения флага prederror. Если prederror = true, выдаётся ошибка,если значения какого-либо из выражений cond1,... ,condn отличаетсяот true или false. Если prederror = false и значения какого-либо из выражений cond1,... ,condn отличается от true или false, результат вычисления if — условное выражение.

 

1.2   Операторы цикла

 

Для выполнения итераций используется оператор textttdo. Могут использоваться три варианта его вызова, отличающиеся условием окончания цикла:

for variable: init_value step increment thru limit do body

for variable: init_value step increment while condition do body

for variable: init_value step increment unless condition do body

Здесь variable — переменная цикла; init_value — начальное значение; increment — шаг (по умолчанию равен 1); limit — конечное значение переменной цикла; body — операторы тела цикла.

Ключевые слова thru, while, unless указывают на способ завершения цикла:

по достижении переменной цикла значения limit;

пока выполняется условие condition;

пока не будет достигнуто условие condition.

Параметры init_value, increment, limit, и body могут быть произвольными выражениями. Контрольная переменная по завершении цикла предполагается положительной (при этом начальное значение может быть и отрицательным). Выражения limit, increment, условия завершения (condition) вычисляются на каждом шаге цикла, поэтому их сложность влияет на время выполнения цикла.

При нормальном завершении цикла возвращаемая величина —атом done. Принудительный выход из цикла осуществляется при помощи оператора return, который может возвращать произвольное значение.

Контрольная переменная цикла — локальная внутри цикла, поэтому её изменение в цикле не влияет на контекст (даже при наличии вне цикла переменной с тем же именем).Условия инициализации и завершения цикла можно опускать.

Пример (цикл без явного указания переменной цикла):

(%i10) x:1000;

(%o10) 1000

(%i11) thru 20 do x: 0.5*(x + 5.0/x)$(%i12) x;

(%o12) 2.23606797749979

(%i12) float(sqrt(5));

(%o12) 2.23606797749979

За 20 итераций достигается точное значение √5.

Несколько более изощрённый пример — реализация метода Нью-

тона для уравнения с одной неизвестной (вычисляется та же величина

— корень из пяти):4.1. Программирование на встроенном макроязыке 209

(%i1) newton (f, x):= ([y, df, dfx], df: diff (f (’x), ’x),

do (y: ev(df), x: x - f(x)/y,

if abs (f (x)) < 5e-6 then return (x)))

$(%i2) f(x):=x^2-5;

(%o2) f (x) := x

2 − 5

(%i3) float(newton(f,1000));

(%o3) 2.236068027062195

Ещё одна форма оператора цикла характеризуется выбором значений переменной цикла из заданного списка. Синтаксис вызова: for variable in list end_tests do body

Проверка условия завершения end_tests до исчерпания списка list может отсутствовать.

Пример:

(%i1) a:[];

(%o1) [ ]

(%i2) for f in [1,4,9,16] do a:cons(sqrt(f),a)$

(%i3) a;

(%o3) [4, 3, 2, 1]

 

1.3   Блоки

 

Как в условных выражениях, так и в циклах вместо простых операторов можно писать составные операторы, т.е. блоки. Стандартный блок имеет вид: block([r,s,t],r:1,s:r+1,t:s+1,x:t,t*t); Сначала идет список локальных переменных блока (глобальные переменные с теми же именами никак не связаны с этими локальными переменными). Список локальных переменных может быть пустым. Далее идет набор операторов. Упрощенный блок имеет вид: (x:1,x:x+2,a:x);

Обычно в циклах и в условных выражениях применяют именно эту форму блока. Значением блока является значение последнего из его операторов. Внутри данного блока допускаются оператор перехода на210 Глава 4. Численные методы и программирование с Maxima метку и оператор return. Оператор return прекращает выполнение текущего блока и возвращает в качестве значения блока свой аргумент block([],x:2,x:x*x, return(x), x:x*x);

В отсутствие оператора перехода на метку, операторы в блоке выполняются последовательно. (В данном случае слово «метка» означает отнюдь не метку типа «%i5» или «%o7»). Оператор go выполняет переход на метку, расположенную в этом же блоке:

(%i1) block([a],a:1,metka, a:a+1,

if a=1001 then return(-a),go(metka));

(%o1) − 1001

В этом блоке реализован цикл, который завершается по достижении «переменной цикла» значения 1001. Меткой может быть произвольный идентификатор.

Следует иметь в виду, что цикл сам по себе является блоком, так что (в отличие от языка C) прервать выполнение циклов (особенно вложенных циклов) с помощью оператора go невозможно, т.к. оператор go и метка окажутся в разных блоках. То же самое относится к оператору return. Если цикл, расположенный внутри блока, содержит оператор return, то при исполнении оператора return произойдет выход из цикла, но не выход из блока:

(%i1) block([],x:for i:1 thru 15 do

if i=2 then return(555),display(x),777);

x = 555

(%o1) 777

(%i2) block([],x:for i:1 thru 15 do

if i=52 then return(555),display(x),777);

x = done

(%o2) 777

Если необходимо выйти из нескольких вложенных блоков сразу(или нескольких блоков и циклов сразу) и при этом возвратить некоторое значение, то следует применять блок catch

 (%i3) catch( block([],a:1,a:a+1, throw(a),a:a+7),a:a+9 );

(%o3) 2

(%i4) a;

(%o4) 2

(%i5) catch(block([],for i:1 thru 15 do

if i=2 then throw(555)),777);

(%o5) 555

В данном блоке выполнение цикла завершается, как только значение i достигает

2. Возвращаемое блоком catch значение равно 555.

(%i6) catch(block([],for i:1 thru 15 do

if i=52 then throw(555)),777);

(%o6) 777

В данном блоке выполнение цикл выполняется полностью, и возвращаемое блоком catch значение равно 777 (условия выхода из цикла при помощи throw не достигаются).

Оператор throw — аналог оператора return, но он обрывает не текущий блок, а все вложенные блоки вплоть до первого встретившегося блока catch.

Наконец, блок errcatch позволяет перехватывать некоторые (к сожалению, не все!) из ошибок, которые в нормальной ситуации привели бы к завершению счета.

Пример:

(%i1) errcatch(a:1, b:0, log(a/b), c:7);

expt: undefined: 0 to a negative exponent.

(%o1) [ ]

(%i2) c;

(%o2) c

 

1.4.Функции чтения файлов в Maxima

 

Среди средств для операций с файлами функции с наиболее очевидными именами — save и load — имеют, вопреки привычной для Maxima логичности всех названий, различный контекст. Первая предназначена для выгрузки Maxima-выражений в виде исходных кодов на Lisp, так что если вы не знаток Lisp (да и реализации внутренних механизмов Maxima), то эта функция представляет лишь чисто академический интерес. Посему подробнее мы займемся другими функциями — для обработки так называемых пакетных (batch) файлов, хранящих выражения уже в синтаксисе самой Maxima. А поскольку в виде таких файлов поставляется немалое количество функционала Maxima, то начнем с загрузки. И вот о второй из очевидно-именуемых функций здесь уже будет рассказано.

Функции чтения файлов с выражениями Maxima существует три: demo(имя-файла), batch(имя-файла) и batchload(имя-файла). Первая предназначена для загрузки так называемых демо-файлов, задуманных, как и явствует из названия, для демонстрационных примеров. Она загружает демо-файл и выполняет его в пошаговом режиме, ожидая нажатия Enter после выполнения каждой строки. В составе Maxima поставляется значительное количество демо-файлов; упоминания о них можно найти в документации, а сами файлы несложно обнаружить среди содержимого пакета maxima-share (либо, в случае отсутствия такового в вашем дистрибутиве, просто maxima) по их расширению — .dem.

Функция batch() загружает Maxima-файл с расширением .mac или .mc (от первоначального названия программы — Macsyma) и выполняет содержащиеся в нем выражения так, как если бы они вводились прямо в текущей сессии, то есть с отображением результата каждого выражения и назначением меток %iN, %oN. Функция batchload(), напротив, подгружает пакетный файл «молча»: все назначенные в нем функции и переменные становятся доступны, но результаты не видны, и весь хранимый ввод-вывод, включая значения символов % и _ и результаты, возвращаемые функцией %th(), остается тем же, что и до вызова.

Функции batch() и batchload() используют при поиске файлов для загрузки путь (точнее сказать, шаблон, потому как в нем содержатся не только имена каталогов, но и допустимые расширения файлов), который хранится в переменной file_search_maxima. По умолчанию эта переменная содержит все каталоги, в которые устанавливаются .mac-файлы из пакетов Maxima, а также ~/.maxima, предназначенный для пользовательских файлов. Для других функций загрузки существуют отдельные переменные: file_search_lisp и file_search_demo, смысл которых понятен из их названий.

Ну и под конец здесь нужно вспомнить о вышеназванной функции load. Она, фактически, является оберткой над двумя функциями: уже описанной выше batchload() и loadfile(), вторая, совершенно аналогично первой, загружает файл, но уже не с выражениями Maxima, а с исходным кодом Lisp, то есть является парной к функции save(). Функцию load() можно, в принципе, использовать вместо batchload(): путь file_search_maxima задан в ней раньше, чем file_search_lisp, так что в случае неоднозначности она будет загружать файлы Maxima; а кроме того, так короче.

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

 

 

Помимо ручной загрузки нужного файла, можно также настроить Maxima на автоматическую подгрузку в случае вызова заданной функции. Делается это так: setup_autoload(имя-файла, имена-функций); нужные функции здесь перечисляются через запятую прямо после имени файла. Удобнее, конечно, будет не вызывать функцию setup_autoload() вручную (так в ней и толку немного), а настроить Maxima на автоматический ее запуск при старте программы. Файл, который, при его наличии, вызывается при каждом запуске Maxima, называется maxima-init.mac и самое логичное для него местоположение — все тот же каталог ~/.maxima. Конечно, он может содержать не только вызовы функции setup_autoload(), а любые выражения Maxima, которые вы хотите выполнять при каждом ее запуске. Использование этой функции может сделать вашу работу с Maxima намного более удобной в том случае, если вы часто используете некоторые из внешних функций Maxima или функции, вами же и написанные.

Для полноценного чтения файлов всего сказанного уже вполне достаточно, теперь перейдем к записи в них. Тут нас в первую очередь интересует функция stringout(), которая позволяет выгружать в файл любые выражения и функции Maxima в точно таком виде, в каком их загружают функцииdemo(), batch() и batchload(). С ее помощью можно писать выражения, которые вы хотите иметь во внешнем модуле, находясь непосредственно в интерфейсе Maxima, с последующей записью в этот самый модуль. Для выгрузки функций в один из стандартных каталогов Maxima (самым логичным вариантом будет, пожалуй, упомянутый выше ~/.maxima) имя файла во всех вариантах вызова функции stringout() нужно задавать с полным путем; в случае задания имени без пути файл будет создан в текущем каталоге, то есть в том, откуда производился запуск Maxima.

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

Эта функция возвращает список всех простых чисел, меньших чем заданное целое число. Сначала мы проверяем, является ли аргумент целым числом и делаем это простейшим образом: в случае невыполнения условия оператор if, напомню, вернет false. Генерируется список тоже самым простым и коротким в реализации способом — рекурсией. (примечание для людей, далеких от программирования: рекурсивная функция — это функция, вызывающая саму себя; чаще всего такие функции строятся по принципу индукции). Здесь используется функция Maxima по имениprev_prime(), которая возвращает простое число, предшествующее заданному целому.

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

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

Теперь, когда у нас уже есть primesbetween(), первую функцию можно написать по «принципу чайника» — сведя задачу к предыдущей:

Теперь вернемся к stringout(). Эта функция, как и многие другие, может принимать несколько различных вариантов аргументов, первым из которых всегда выступает имя файла для записи, а остальные отвечают за то, что же именно будет туда записано. В варианте stringout(имя-файла, [начало, конец]) записаны будут ячейки ввода с номерами от «начала» до «конца» включительно:

$ cat .maxima/primes.mac

primes(n):=if integerp(n) then (if n <= 2 then [] else

append(primes(prev_prime(n)),[prev_prime(n)]));

primesbetween(n,m):=if integerp(n) and integerp(m) then

(if m <= 2 or prev_prime(m) <= n then [] else

append(primesbetween(n,prev_prime(m)),[prev_prime(m)]));

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

$ cat .maxima/primes.mac

primes(x):=if integerp(x)

      then (if x <= 2 then []

              else append(primes(prev_prime(x)),[prev_prime(x)]));

primesbetween(n,m):=if integerp(n) and integerp(m)

            then (if m <= 2 or prev_prime(m) <= n then []

                    else append(primesbetween(n,prev_prime(m)),

                            [prev_prime(m)]));

Представления о правилах отступов у создателей этой опции несколько специфичные, но тем не менее, результат стал намного читабельнее. Так что, если вы планируете сохранять выражения Maxima не только для того, чтобы потом загружать их обратно, а желаете редактировать созданные файлы, я рекомендую вам прописать grind:true глобально в файле ~/.maxima/maxima-init.mac.

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

$ cat primes-sample.mac

primes(n):=if integerp(n)

      then (if n <= 2 then []

              else append(primes(prev_prime(n)),[prev_prime(n)]));

primesbetween(n,m):=if integerp(n) and integerp(m)

            then (if m <= 2 or prev_prime(m) <= n then []

                    else append(primesbetween(n,prev_prime(m)),

                            [prev_prime(m)]));

primes1(n):=primesbetween(1,n);

stringout(".maxima/primes.mac",[1,2]);

grind:true;

stringout(".maxima/primes.mac",[1,2]);

(N:[random(100000)],for i thru 9 do N:append(N,[N[i]+random(100000)]),N);

(P:[],for i thru 10 do P:append(P,primesbetween(N[i]-50,N[i])),P);

Кроме input, есть еще два ключевых слова: functions и values. Первое позволяет записать определения всех функций, второе — присвоение всем символам выражений их текущих значений:

$ cat .maxima/primes.mac

primes(n):=if integerp(n)

      then (if n <= 2 then []

               else append(primes(prev_prime(n)),[prev_prime(n)]));

primesbetween(n,m):=if integerp(n) and integerp(m)

             then (if m <= 2 or prev_prime(m) <= n then []

                     else append(primesbetween(n,prev_prime(m)),

                             [prev_prime(m)]));

primes1(n):=primesbetween(1,n);

$ cat primes-sample.mac

primes(n):=if integerp(n)

      then (if n <= 2 then []

               else append(primes(prev_prime(n)),[prev_prime(n)]));

primesbetween(n,m):=if integerp(n) and integerp(m)

             then (if m <= 2 or prev_prime(m) <= n then []

                     else append(primesbetween(n,prev_prime(m)),

                             [prev_prime(m)]));

primes1(n):=primesbetween(1,n);

N:[49900,61971,153219,244360,290427,347723,396481,465378,522906,568462];

P:[49853,49871,49877,49891,61927,61933,61949,61961,61967,153191,244313,244333,

  244339,244351,244357,290383,290393,290399,290419,347707,347717,396437,

  396443,396449,396479,465331,465337,465373,522857,522871,522881,522883,

  522887,568433,568439,568441,568453];

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

$ cat .maxima/primesbetween.mac

primesbetween(n,m):=if integerp(n) and integerp(m)

           then (if m <= 2 or prev_prime(m) <= n then []

                   else append(primesbetween(n,prev_prime(m)),

                           [prev_prime(m)]));

$ cat .maxima/primes1.mac

primes(n):=if integerp(n)

      then (if n <= 2 then []

              else append(primes(prev_prime(n)),[prev_prime(n)]));

primes1(n):=primesbetween(1,n);

А для символов можно использовать небольшую хитрость: блокировать вычисление переданного выражения, а в нем написать сначала сам символ, а потом через двоеточие — его же, предварив знаком принудительного вычисления (два апострофа):

$ cat random-primes.mac

P:[49853,49871,49877,49891,61927,61933,61949,61961,61967,153191,244313,244333,

  244339,244351,244357,290383,290393,290399,290419,347707,347717,396437,

  396443,396449,396479,465331,465337,465373,522857,522871,522881,522883,

  522887,568433,568439,568441,568453];

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

Теперь поговорим о функциях, позволяющих налагать определенные условия на выражения, которыми оперирует Maxima. Таких функций существует две, и достаточно разноплановых; но определенная связь между ними есть, так как все условия, заданные ими на данный момент, хранятся в общей «базе». Первая из этих функций называется declare (объявлять). С ее помощью можно объявлять весьма разнообразные факты о произвольных символах или выражениях; синтаксис ее весьма прост: declare(имя, факт) или declare(имя₁, факт₁, имя₂, факт₂, …); факты задаются с помощью ключевых слов. Сами факты я бы разделил на три группы: «технические» факты Maxima, позволяющие использовать наделенный ими символ некоторым специальным образом при вводе выражений; факты о символах (атомарных выражениях); и факты о значениях функций. К первым относятся, к примеру, свойства evflag и evfun, о которых шла речь в описании функции ev; некоторые штатные функции обладают ими по умолчанию, а с помощью функции declare мы можем присвоить эти свойства любым другим, в том числе и пользовательским, функциям. Вторая группа фактов несет информацию о неизвестных; например, мы можем указать, что некоторая неизвестная является константой, или что ее значение — целое. И третья группа — примерно то же самое, но о функциях; примеры: четная функция (f(−x) = f(x)), аддитивная (f(x + y) = f(x) + f(y)) или целочисленная. Для краткости просто перечислим наиболее интересные из возможных фактов, сгруппировав соответственно трем упомянутым группам.

Технические факты evfun

Позволяет применять функцию или переменную как опцию, то есть «выражение, имя-функции» вместо «имя-функции(выражение)» или «выражение, имя-переменной» вместо «имя-переменной:true; выражение».

bindtest

Запрещает использовать символ в выражениях до присвоения ему значения. При таком использовании Maxima выдаст ошибку. Пример см. в документации.

feature

Делает заданное имя именем свойства (факта), что дает возможность использовать его точно так же, как все перечисленные здесь имена.

Факты о символах

constant

Имя трактуется как константа.

scalar

Имя трактуется как скалярная величина. На это также влияет флаг assumescalar: если он равен true, то все неопределенные символы воспринимаются как скаляры. Тут есть небольшая коллизия: если верить документации, то по умолчанию assumescalar равен false, реально же в Maxima 5.10.0 он равен true.

nonscalar

Имя трактуется как не-скалярная величина, то есть матрица или вектор. integer, noninteger

Целое и нецелое число.

even, odd

Четное и нечетное целое число.

Факты о функциях

rassociative

Объявляет функцию как «ассоциативную» по правому аргументу.

lassociative

Аналогично — по левому аргументу.

nary

Объявляет «n-арную» функцию. Это и два предыдущих названия не совсем точны: n-арной правильно называть функцию от n аргументов, а лево- и правоассоциативной — функции именно с односторонней ассоциативностью, то есть, для «лево-» f(f(a,b),c) ≠ f(a,b,c) ≠ f(a,f(b,c)). А в Maxima все три факта объявляют на самом деле полно-ассоциативную функцию от произвольного числа аргументов, а различаются только тем, как будут расставлены скобки по умолчанию.

symmetric/commutative

Оба ключевых слова объявляют функцию как симметричную (коммутативную).

antisymmetric

Объявляет функцию как антисимметричную.

outative

Константа выносится за знак функции.

Многие из фактов, которые можно устанавливать с помощью функции declare, сохраняются в «базе данных» фактов. Узнать текущее состояние этой базы можно с помощью функции facts(). Ее можно вызывать, либо передав в качестве единственного аргумента имя, список фактов по которому мы хотим получить, либо вообще без аргументов — тогда будут выданы все известные факты обо всех пользовательских именах. Удалить свойства позволяет функция remove(). Она, как и многие другие, имеет несколько вариантов вызова. Будучи вызвана как remove(имя, свойство) илиremove(имя₁, свойство₁, имя₂, свойство₂, …), она лишает каждое переданное имя одного соответствующего ему свойства. Можно также передавать ей списки имен и свойств: remove([имя₁, имя₂, …], [свойство₁, свойство₂, …]); тогда каждое имя из списка будет лишено всех перечисленных свойств. Пар списков тоже может быть более одной: remove(список-имен₁, список-свойств₁, список-имен₂, список-свойств₂, …) — этот вызов аналогичен последовательным remove(список-имен₁, список-свойств₁); remove(список-имен₂, список-свойств₂);… И последний интересующий нас вариант —remove(all, свойство) удаляет «свойство» со всех имен, у которых оно есть.

Вторая «условная» функция — это функция assume() (допускать, принимать). Здесь все проще: в качестве аргументов ей можно передавать в любом количестве самые обыкновенные равенства и неравенства. Напомню только, что задавать их нужно не в синтаксической, а в логической форме, то есть не «a=b», «a#b», а «equal(a,b)», «not equal(a,b)». Из логических операторов допускается также использование and (по сути assume(x>0 and x<1)это то же самое, что и assume(x>0, x<1)), но не or — база фактов не поддерживает информацию вида «или»; и речь не о синтаксисе, а именно о конструкциях, то есть выражения типа not(a>b and a<c) тоже недопустимы. Факты, добавленные assume(), также видны функции facts():

Ключевое слово kind используется только для отображения тех фактов из базы, которые добавлены с помощью declare().

Если факты, заданные функцией declare(), удаляются вызовом remove(), то для assume() есть своя «обратная» функция — forget(), которая также принимает любое количество условий (точно таких же как и assume()), либо в качестве отдельных аргументов, либо списком.

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

Еще один пример использования assume()/declare() — возможность избежать неопределенностей. Вы, возможно, помните, как в одном из примеров статьи «Maxima. Алгебра и начала анализа» в ответ на попытку посчитать некий интеграл Maxima задала нам вопрос о знаке входящего в него символа. Вот в таких ситуациях тоже может пригодиться assume, дабы предвосхитить расспросы:

Наряду с простейшим способом задания функции, Maxima допускает создание функции в виде последовательности операторов:

 f(x):= (expr1, expr2, ..., exprn);

Значение, возвращаемое функцией— значение последнего выражения exprn.

Чтобы использовать оператор return и изменять возвращаемое значение в зависимости от логики работы функции, следует применять конструкцию block, например: f(x)=block ([], expr1, ...,

if (a > 10) then return(a), ..., exprn).

При a > 10 выполняется оператор return и функция возвращает значение a, в противном случае — значение выражения exprn.

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

Пример:

block ([a: a], expr1, ..., a: a+3, ..., exprn)

В данном случае при объявлении блока в локальной переменной a сохраняется значение глобальной переменной a, определённой извне блока.

Пример:

(%i1) f(x):=([a:a],if a>0 then 1 else (if a<0 then -1 else 0));

(%o1) f (x) := ([a : a], if a > 0 then 1 else if a < 0 then − 1 else 0)

(%i2) a:1;

(%o2) 1

(%i3) f(0);

(%o3) 1

(%i4) a:-4;

(%o4) −4

(%i5) f(0);

(%o5) −1

(%i6) a:0;

(%o6) 0

(%i7) f(0);

(%o7) 0

В данном примере значение переменной a задаётся вне тела функции, но результат, возвращаемый ею, зависит от значения a.

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

• Задание функции f(x) := (expr1, ..., exprn);, вызов функции f(1); — начальное значение локальной переменной x равно 1.

• Задание блока block ([x: 1], expr1, ..., exprn), при этом начальное значение локальной переменной x также равно 1.

Наряду с именованными функциями, Maxima позволяет использовать и безымянные функции (лямбда-функции). Синтаксис использования лямбда-выражений (правда, при использовании с лямбда-выражениями всё-таки ассоциируется имя — см. пример):

f1 : lambda([x1,... ,xm],expr1,... ,exprn)

f2 : lambda([[L]],expr1,... ,exprn)

f3 : lambda([x1,... ,xm, [L]],expr1,... ,exprn)

Пример:

(%i1) f: lambda ([x], x^2);

(%o1) lambda ¡

[x],x2

¢

(%i2) f(a);

(%o2) a

2

2.Контекст вычисления

 

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

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

 

2.1Блокировка вычислений

 

Попробуем сложить две переменные. А теперь поставим перед ними символ одинарной ковычки. Это оператор блокировки вычислений. Если мы поставим его перед именем переменной — в результате получим имя этой переменной, перед вызовом функции — символьное выражение вызова функции. Зачем? Иногда вам может потребоваться с помощью одной функции обработать выражение другой функции и на выходе получить функцию или число, например вычисление неопределенного интеграла. Другими словами вы имеете возможность представлять выражение как данные и манипулировать с ним. Однако если вы попробуете остановить вычисление суммы двух чисел, то вычисления не прекратятся. Это связано с тем, что оператор одинарной кавычки не останавливает простейшего упрощения выражения (простые операции над числами, сокращение дробей). Так же вычисления не остановятся, если вы попытаетесь посчитать значение функции рационального (float) аргумента.
И так, система Maxima не различает функции алгоритмические и функции математические, в ней они являются одним языковым элементом. В терминологии самого интерпретатора, операторы которые могут быть вычислены называются verb, те операторы, которые так остаются в невычесленом виде называются noun. Для инициирования вычисления всех noun необходимо в контексте вычислений выставить опцию nouns.

 

2.2Вычисления

 

Мы узнали, что интерпретатор различает понятия символьного выражения и его вычисления. В каких случаях происходит вычисление? Самый очевидный случай — когда мы пытаемся посчитать какое то выражение (2+3, например). Ввели выражение — получили его значение. Посчитали функцию от аргумента — получили значение. Ввели имя переменной — получили ее значение. Мы узнали, что значением у переменной может быть как атом, так и символьное выражение. Когда еще происходит вычисление? Вычисление происходит при присваивание переменной значения. Значение стоящее справа от двоеточия вычисляется перед присвоением, поэтому при присвоении переменной символьного выражения мы ставим кавычку, что бы остановить это вычисление. Есть особенный вид присвоения (оператор два двоеточия), когда вычисляется как выражение справа, так и выражение слева. Так же перед вычислением функции вычисляются все ее аргументы. 

Результатом вычисления переменной a слева оказывается переменная b

 

 

 

 

 

 

Заключение

 

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Литература

 

1.Документация по текущей версии пакета: http://maxima. sourceforge.net/docs/manual/en/maxima.html

 2.В. А. Ильина, П. К. Силаев. Система аналитических вычислений Maxima для математиков. М.:МГУ им. М. В. Ломоносова, 2007. — 113 с. http://tex.bog.msu.ru/numtask/max07.ps

 3. Статьи Тихона Тарнавского http://maxima.sourceforge.net/ ru/maxima-tarnavsky-1.html

4. http://www.pmtf.msiu.ru/chair31/students/spichkov/ maxima2.pdf (Методическое пособие по изучению математического пакета Maxima) Математический практикум с применением пакета Maxima. (PDF)

5.Н. А. Стахин. Основы работы с системой аналитических (символьных) вычислений MAXIMA (ПО для решения задач аналитических (символьных) вычислений). — Москва: Федеральное агентство по образованию, 2008 — 86 с.

6.Книга по Maxima (электронное руководство) http://maxima. sourceforge.net/docs/maximabook/maximabook-19-Sept-2004. pdf