М. М. Нишева-Павлова



Дата15.03.2017
Размер176.26 Kb.


УДК 681.3.06
СИСТЕМАТА MATHEMATICA И НЯКОИ ВЪЗМОЖНОСТИ

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


М. М. Нишева-Павлова

В статията е представен накратко езикът за програмиране на системата Mathematica. Анализирани са включените в този език средства за функционално програмиране, процедурно програмиране и програмиране в областта на изкуствения интелект, основано на използване на т. нар. преобразуващи правила. С помощта на множество примери са илюстрирани възможностите за използване на езика на Mathematica в съответни университетски курсове по програмиране.





  1. ВЪВЕДЕНИЕ

Mathematica [3,4] е широко разпространена универсална система за компютърна алгебра [1], предназначена предимно за изследователски приложения. Тя може да се разглежда като интегрирана съвкупност от програмна система и език за програмиране, предназначени за решаване на математически задачи.

Вградените средства на Mathematica са ориентирани към решаване на задачи в множество области, най-типичните от които са:


  • алгебра (опростяване и преобразуване на изрази, работа с вектори и матрици, намиране на базис на Грьобнер, решаване на алгебрични уравнения и системи уравнения и др.);

  • математически анализ (намиране на граници на функции, диференциране, интегриране, разлагане в редове, работа със специални математически функции и др.);

  • диференциални уравнения;

  • числени методи;

  • теория на вероятностите и математическа статистика;

  • компютърна графика (създаване на двумерни и тримерни графични изображения, в частност визуализация на функции; анимация на графични обекти и др.).

Mathematica поддържа свой собствен език за програмиране [2,4], който предоставя средства за процедурно програмиране, функционално програмиране и програмиране чрез т. нар. преобразуващи правила.

Предвидени са средства за лесно документиране и публикуване на резултати, получени с помощта на Mathematica. За целта изходът, генериран от системата, може да бъде конвертиран в избран от потребителя формат и да бъде включен без проблеми в учебни материали или статии.





  1. ПРОЦЕДУРНО ПРОГРАМИРАНЕ

Сред типичните конструкции, които поддържат процедурния стил на програмиране в Mathematica, са оператори за присвояване (незабавно и отложено), условни оператори (с едно условие и с променлив брой условия), оператори за цикъл (while и for) и др. Операторите за присвояване ще бъдат разгледани детайлно в т. 4, тъй като по същество те представляват глобални преобразуващи правила.

По-нататъшното изложение съществено използва понятието израз в Mathematica. Изразите са основните конструкции, с които работи интерпретаторът. На всяка стъпка от работния си цикъл интерпретаторът изчаква потребителя да въведе синтактично коректен израз, оценява този израз и връща получената оценка като резултат. Понятието израз може да се дефинира рекурсивно. Най-напред, изрази са т. нар. атоми (атомарни изрази): символи, числа, низове. Произволен (в частност, атомарен) израз в Mathematica има вида h[e1,e2, … , en], където h се нарича заглавие на израза, а e1, e2, ... , en - подизрази, елементи или части на израза. Заглавието и елементите на един израз могат да бъдат изрази. Следователно, стандартно в Mathematica изразите се записват в префиксна форма.

Ако заглавието на даден израз е символ, то са възможни различни интерпретации на неговия смисъл. Заглавието може да се възприеме като име на математическа функция (Sin, Exp и т.н.), като команда (Factor, Delete и т.н.) или като тип данни (Integer, List и т.н.). Всички вградени (системни) заглавия започват с главна буква.

Казаното по-горе относно префиксния запис на изразите в Mathematica се отнася до тяхната вътрешна или пълна форма, т.е. до тази форма, която се възприема от изчислителното ядро на системата. Синтаксисът на изразите, които потребителят въвежда от клавиатурата, може да се различава от синтаксиса на пълната им форма.

Изходният формат на изразите е нелинеен и е максимално близък до традиционното представяне на математическите изрази.




    1. Условни оператори

Изразът If[test,expr1,expr2] връща като резултат оценката на expr1, ако оценката на test е True, или оценката на expr2, ако оценката на test е False. Ако оценката на test не е нито True, нито False, то като резултат се връща неоцененият входен израз със заглавие If.

Условната функция Which[test1,expr1,test2,expr2, … ,testN,exprN] има четен брой (2N) аргументи. В процеса на оценяване на обръщението към Which се оценяват последователно тестовете test1, test2, … и се връща като резултат оценката на първия израз expri, за който предхождащият го тест testi има стойност True, а всички предишни тестове имат стойност False. Ако първите k теста имат оценка False, а k+1 – вият има небулева оценка, то като резултат се връща неоцененото обръщение към Which. Ако всички тестове имат оценка False, оценката на обръщението към Which е Null.




    1. Съставни изрази. Оператор Do

Поредица от изрази на Mathematica, разделени един от друг с точка и запетая, образуват т. нар. съставен израз (израз със заглавие CompoundExpression).

Оператор, който в определен смисъл имитира CompoundExpression, е операторът Do. При оценяването на израза Do[expr,{imax}] изразът expr се оценява последователно imax пъти. Този Do израз е еквивалентен на израза expr; expr; … ; expr;, в който знакът ; е поставен и след последния израз expr. По такъв начин след завършване на процеса на оценяване получената оценка не се записва в съответната изходна клетка, въпреки че изразът expr е пресметнат.

При пресмятането на израза Do[expr,{i,imax}] изразът expr, който може да съдържа символа i, се оценява последователно imax пъти, като при това i се променя от 1 до imax със стъпка 1. Списъците {imax} и {i,imax} в оператора Do се наричат итератори. Итераторът може да бъде зададен и във вида {i, imin,imax,step}, където imin и imax са съответно началната и крайната стойност на i, а step е стъпката, с която се променя i. Ако параметърът step отсъства, то неговата стойност по премълчаване е равна на 1.


    1. Оператори за цикъл

Цикълът със заглавие While има вида While[test,expr]. Неговото оценяване започва с проверка на условието (теста) test. Ако test има стойност True, изчислява се изразът expr. При това би трябвало в процеса на оценяване на expr по някакъв начин да се променя test. По-нататък отново се проверява тестът test и описаният процес продължава, докато на дадена стъпка оценката на test стане различна от True. В такъв случай цикълът се прекратява и като оценка на обръщението към While се получава Null.

Операторът за цикъл със заглавие For действа по следния начин. При оценяването на израза For[start,test,step,expr] най-напред се изчислява началният израз start (най-често start съдържа присвояване на стойност на дадена променлива). След това многократно се изчисляват изразите expr и step, докато оценката на условието test стане различна от True. Както и при цикъла While, формалната оценка на обръщението към For е Null.




    1. Дефиниране на локални променливи

Локални променливи в Mathematica се дефинират с помощта на функцията Module. Тази функция има два аргумента. Първият е списъкът от локални променливи, валидни в рамките на тялото (втория аргумент на Module), а вторият е израз, който определя областта на действие на тези локални променливи. Оценката на втория аргумент се връща като оценка на обръщението към Module. Следователно, обръщението към Module има следния общ вид: Module[{x,y, … }, expr] .

Тук x, y, … са имената на локалните променливи, валидни в тялото на Module (израза expr). Възможно е за някои от локалните променливи да бъдат определени начални стойности.




    1. Примери

Във всички примери в настоящия и следващите параграфи изразите, въвеждани от потребителя, ще бъдат с получерен шрифт, а резултатите, извеждани от интерпретатора – с обикновен шрифт.

Do[Print[i a+j b],{i,3},{j,i}]


a + b

2 a + b


2 a + 2 b

3 a + b


3 a + 2 b

3 a + 3 b



x=10; While[x>5, Print[x"> 5"];x--]

10 > 5


9 > 5

8 > 5


7 > 5

6 > 5




  1. ФУНКЦИОНАЛНО ПРОГРАМИРАНЕ

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




    1. Дефиниране на функции

Дефинирането на функция със заглавие (име) name и формални параметри par1, par2, … , parn се извършва с помощта на израз от вида

name[par1_,par2_, … ,parn_] := expression .

Тук expression е израз, който определя тялото на дефинираната функция. Употребата на отложеното присвояване Set-Delayed (:=) при дефинирането на функции ще бъде дискутирана детайлно в т. 4. Дефинираните от потребителя функции могат да бъдат използвани по същия начин, както и вградените.

По този начин се дефинират функции, които имат свои заглавия и в този смисъл могат да бъдат наречени именувани функции. Такива функции е полезно да бъдат дефинирани, когато те ще се използват многократно в процеса на работа със системата. В противен случай е добре да се работи с т. нар. чисти функции, които се използват само в момента на тяхното дефиниране. За дефиниране на чисти функции се използва вградената функция Function. Обръщението към нея има вида Function[parameter-list,expr], където parameter-list е списъкът от формалните параметри на дефинираната функция, а expr е израз, който определя тялото на тази функция. Прилагането на една чиста функция към съответните фактически параметри се извършва по стандартния за системата Mathematica начин.

По-компактно (и често по-удобно) дадена чиста функция може да се представи под формата на т. нар. анонимна функция. В анонимните функции за означаване на формалните параметри се използват специални изрази на Mathematica със системното заглавие Slot, които имат вида #, #1, #2 и т.н. При това при функции на една променлива за означаване на аргумента се използва #, а при функции на няколко променливи първият аргумент се означава с #1, вторият – с #2 и т.н. В края на анонимната функция се поставя знакът &. Например функцията на един аргумент, която пресмята квадрата на този аргумент, може да се запише във формата на анонимна функция като #^2&.




    1. Суперпозиция на функции

Важен компонент на функционалното програмиране е последователното прилагане или суперпозицията на функции. В Mathematica има две вградени функции, Nest и Fold, които автоматизират описанието на суперпозиции на една и съща функция. Нека предположим, че е необходимо дадена функция function да бъде приложена n пъти към даден аргумент x, като най-напред function се приложи към x, после към получения резултат, след това – към получения при повторното прилагане резултат и т.н. Изразът Nest[function,x,n] може да бъде използван за реализация на посочената поредица от действия.

Функцията NestList е разновидност на Nest. NestList[function,x,n] връща като резултат списък, първият елемент на който е x, вторият – резултатът от прилагането на function към x и т.н. Последният елемент на получения списък съвпада с резултата, който връща Nest[function,x,n].

Двойката функции Fold и FoldList са аналог съответно на Nest и NestList по отношение на прилагането на функции на два аргумента. Изразът FoldList[f,x,{a,b, … }] генерира списък от вида {x,f[x,a],f[f[x,a],b], … }, а като оценка на обръщението към функцията Fold със същите аргументи се получава последният елемент на посочения списък.

Ако към даден аргумент x трябва последователно да се приложат функциите f1, f2, … , fn, за целта може да се използва вградената функция Composition. По-точно, описаният резултат може да бъде получен при оценка на обръщението



Composition[fn, … ,f2,f1][x] .

Функцията ComposeList[{f1,f2, … ,fn},x] действа аналогично на Composition и връща списък от поредните резултати от прилагането на функциите от дадения списък към x.




    1. Алгебра на функции

Функцията идентитет в Mathematica има заглавие Identity .

Ако f е заглавието на дадена функция, то с помощта на InverseFunction[f] може да се определи формално обратната функция на f.

Формалността на горното определение се състои в това, че със заглавието f(-1), което се получава като оценка на обръщението InverseFunction[f], не се свързват автоматично никакви правила за конкретно пресмятане на обратната функция.

По същество разглежданата алгебра на функции представлява по-скоро алгебра на заглавията на функциите. Заглавията на функции могат да се събират и умножават помежду си и с естествени числа, т.е. могат да се въвеждат обекти от типа на f+g, f g, 2f и т.н.




    1. Прилагане на функции към списъци

Резултатът от прилагането на дадена функция f (или по-точно, на заглавието на функцията f) към даден списък list е изразът f[list], чиито входни форми могат да бъдат още f@list или list//f.

Ако се опитаме да намерим стойностите на много от вградените функции на Mathematica за аргументи, които са списъци, ще се натъкнем на неочаквани резултати.

Примери

Sqrt[{1,2,3}]


{1,Sqrt[2],Sqrt[3]}

x^{1,2,3}

{x,x2,x3}

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

f@{1,2,3}

f[{1,2,3}]

Вградената функция Map дава възможност на останалите функции да се държат като дистрибутивни. Map[f,list] (с инфиксен запис f/@list) предизвиква прилагане на f към всеки от елементите на list и връща като резултат списък от получените оценки. В процеса на оценяване на обръщението Map[f,list,{n}] функцията f се прилага към елементите на list, които се намират на n-то ниво на вложение.

За прилагане на дадена функция f към аргументи – елементите на списъка list може да се използва вградената функция Apply[f,list] (с инфиксен запис f@@list).

Вградената функция MapThread обединява действието на горните функции.

Пример

MapThread[f,{{a,b},{2,3},{x,y}}]


{f[a,2,x],f[b,3,y]}

Вградената функция Inner обобщава действието на MapThread. Изразът Inner[f,list1,list2, … ,listn,g] е еквивалентен на Apply[g,MapThread[f,{list1, list2, … , listn}]]. При това аргументите list1, list2, … , listn могат да имат еднакви заглавия, които не са непременно List.




    1. Примери

cube[x_]:=x^3

{cube[2],cube[x],cube[y]}

{8,x3,y3}


Map[cube,{a,b,3}]


{a3,b3,27}

poly[x_,y_]:=a x^2+b y

MapThread[poly,{{x,y,z},{u,v,w}}]


{b u + a x2,b v + a y2,b w + a z2}

average[x_]:=Apply[Plus,x]/Length[x]

average[{13,7,16}]

12

l={5,3,7,1,8,9,2,4};



Sort[l,#1^2>#2&]

{5, 3, 7, 8, 9, 4, 2, 1}


Select[l,N[Sqrt[#]]<2.5&]


{5, 3, 1, 2, 4}

fact[n_]:=Fold[Times,1,Range[n]]

fact[5]

120


flat[lst_]:= Which[lst==={},{},

AtomQ[First[lst]],Prepend[flat[Rest[lst]],First[lst]],

True,Join[flat[First[lst]],flat[Rest[lst]]]]

flat[{{1,{2}},{3,{4,{5,6}}},7,{{{{8}}}}}]

{1, 2, 3, 4, 5, 6, 7, 8}



filter[l_,f_]:= Apply[Join,Map[Function[{x},

If[f[x],{x},{}]],l]]

filter[{a,b,1,2,c,3,d,e,f,4,g,5},NumberQ]

{1, 2, 3, 4, 5}



CntEl[l_]:=Module[{ll=Union[l], ss={}},

Do[For[i=1; s[j]=0, i<=Length[l], i++,

If[l[[i]]===ll[[j]], s[j]=s[j]+1]],

{j,Length[ll]}];

Do[ss=Append[ss,s[i]],{i,Length[ll]}];

MapThread[List,{ll,ss}]]

CntEl[{a,b,c,b,d,e,a,b,c,b,e}]

{{a, 2}, {b, 4}, {c, 2}, {d, 1}, {e, 2}}



Забележки:

  • Length е вградена функция, която намира броя на елементите на даден списък;

  • Select е вградена функция, която за дадени списък list и функция – предикат filter връща като резултат списък от тези елементи на list, за които функцията filter връща стойност True;

  • Sort е вградена функция, предназначена за сортиране на даден списък list. Тя има втори, незадължителен аргумент, който определя критерия на сортирането. Ако този аргумент не е посочен, сортирането се извършва в съответствие с вградената в системата наредба. В противен случай вторият аргумент трябва да бъде двуместен предикат и сортирането се извършва по такъв начин, че този предикат да има стойност True за всяка двойка поредни елементи на резултата;

  • Join е вградена функция, чрез която се формира обединението (по-точно, конкатенацията) на елементите на няколко списъка. Prepend[list,el] добавя el в началото на списъка list, а Append[list,el] добавя el в края на списъка list;

  • Вградената функция First връща като резултат първия елемент на даден списък, а функцията Rest връща списъка без първия му елемент;

  • Range[n], където n е естествено число, връща като резултат списъка {1,2, … ,n}.



  1. ПРОГРАМИРАНЕ ЧРЕЗ ПРЕОБРАЗУВАЩИ ПРАВИЛА

Езикът на Mathematica предоставя средства за дефиниране и използване на глобални и локални правила за преобразуване на изрази. Особено интересни тук са възможностите за определяне на разнообразни шаблони, дефиниращи класовете от изрази, върху които се прилага определено правило, както и средствата за многократно последователно прилагане на група правила.




    1. Глобални и локални преобразуващи правила

Изразът x=a, който в традиционните езици за програмиране е пример за оператор за присвояване, може да бъде разглеждан като най-просто преобразуващо правило, съгласно което във всички следващи изрази на Mathematica символът x трябва да бъде заменен със символа a. В този смисъл разглежданото правило е глобално. Негов локален аналог е субституцията x->a, която се извършва в определени от потребителя изрази след прилагане към тях на функцията ReplaceAll (с входен инфиксен формат /.).

Знакът = представлява инфиксна форма на двуаргументната функция Set. Изразът Set[expr1,expr2] се пресмята по следния начин. Пресмята се изразът expr2 и полученият резултат се присвоява на неоценения израз expr1. При това ще отбележим специално, че на мястото на expr1 може да бъде поставен произволен израз, а не само символ. Пример:



a[x^2]=E^x

Ex

След това всички срещания на a[x2] ще бъдат замествани с Ex.

Нека обаче опитаме да определим следното преобразуващо правило:


x^2=b

Set:: write: Tag Power in x2 is Protected.


b

Полученото съобщение означава, че заглавието (функцията) Power в израза x2 има атрибут Protected. Това от своя страна означава, че с изразите x2, x3, Sqrt[x], както и с произволен израз от вида Power[expr,k] със заглавие Power не е възможно без специални усилия да се свърже преобразуващо правило с помощта на функцията Set.

Последният пример показва също, че Mathematica асоциира преобразованието със заглавието на израза expr1 от Set[expr1,expr2]. Това обстоятелство позволява да се дефинират нови функции чрез обръщения към Set като например

f[x_]=x^3

x3

В изразите от този вид символът x се следва от знака за подчертаване _, който е входна форма на израза Blank[]. След оценяването на горната дефиниция f[expr], където expr може да бъде произволен израз, ще се замества винаги с expr3 и това преобразуващо правило ще бъде неразривно свързано със заглавието f, като ще представлява една от т. нар. down стойности (DownValues) на това заглавие.

С всяко заглавие могат да бъдат асоциирани произволен брой down стойности. Ще отбележим, че Mathematica прилага преобразуващите правила, свързани с даден символ, в реда, в който те са записани в списъка - оценка на обръщението към функцията DownValues за посочения символ. В този списък винаги по-частните правила предшестват по-общите.

Освен Set за дефиниране на глобални преобразуващи правила се използва и функцията SetDelayed (отложено присвояване), чиято входна форма е expr1:=expr2. Оценяването на израза expr1:=expr2 се свежда до това, че expr1 и expr2 не се оценяват, но съответното правило се включва в списъка на down стойностите на заглавието на израза expr1. Ако по-нататък възникне необходимост от пресмятане на израза expr1, този израз се замества с текущата (пресметнатата в текущия момент) оценка на expr2.

Ако заглавието на дадена функция, с която е желателно да се асоциират нови преобразуващи правила, има атрибут Protected, този атрибут може да бъде подтиснат с помощта на вградената функция Unprotect, след което без проблеми могат да се дефинират необходимите преобразуващи правила.

Локални преобразуващи правила могат да се дефинират чрез функциите Rule[expr1,expr2] (локален аналог на Set с входна инфиксна форма expr1->expr2) и RuleDelayed[expr1,expr2] (локален аналог на SetDelayed с входна инфиксна форма expr1:>expr2). И двата вида локални преобразуващи правила се прилагат с помощта на функцията ReplaceAll (с инфиксна форма /.).


    1. Шаблони

Шаблоните са средство за определяне на (по-широки или по-тесни) класове от изрази в системата Mathematica. Най-общият шаблон има вида _ и определя клас, който се състои от всички допустими изрази в Mathematica. Конкретните изрази от вида h[e1, … ,en] са шаблоните с най-малка общност, определящи класове, които се състоят само от един израз. Останалите шаблони заемат междинно положение по отношение на степента си на общност.

Казва се, че даден израз съответства на (е съпоставим с) даден шаблон, ако изразът принадлежи на класа, определен от шаблона.

Шаблонът _ може да бъде снабден с име, което трябва да бъде символ. Именуваният шаблон _ има вида symbol_. Името на шаблона не оказва влияние върху класа изрази, определени от него. Освен това, може да се посочва заглавието на шаблона чрез форма от вида _head. Заглавието съществено ограничава класа на изразите, съпоставими със съответния шаблон.

Освен шаблоните, основани на символа за подчертаване _, има още шаблони от вида __ (двойно подчертаване, BlankSequence[]) и ___ (тройно подчертаване, BlankNullSequence[]). Двойното подчертаване определя клас изрази, които се състоят от един или няколко израза, разделени със запетаи. Например изразът h[e1,e2,e3] съответства на шаблона h[x__]. Тройното подчертаване определя клас изрази, които се състоят от нула, един или няколко израза, разделени със запетаи. Последните два шаблона също могат да бъдат снабдени с имена. Шаблоните __head и ___head изискват всички изрази от съответната поредица да имат заглавие head.

В шаблоните, основани на знака _, може да не само да се фиксира заглавието на съответните изрази, но и да се включи определен предикат, който трябва да бъде удовлетворен.


    1. Използване на шаблони в локални преобразуващи правила

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

Локалните преобразуващи правила съдържат субституции от вида expr1->expr2 или expr1:>expr2, където в expr1 може да участват шаблони. Субституциите се извършват с помощта на функциите ReplaceAll (/.) и ReplaceRepeated (//.).

Функцията ReplaceAll прилага дадена субституция към определен израз, а функцията ReplaceRepeated е предназначена за последователно прилагане на списък от субституции към даден израз. Пресмятането на резултата от обръщението към функцията ReplaceRepeated се свежда до многократно прилагане на функцията ReplaceAll, докато всички подизрази на преобразувания израз станат несъпоставими с дадените шаблони (с шаблоните от дадения списък). При това редът на съпоставянето с шаблоните е следният. Първият шаблон от дадения списък се използва, докато в преобразувания израз има поне един подизраз, съответен на този шаблон. След това се разглежда вторият шаблон и т.н. Допълнително работата на ReplaceRepeated може да бъде управлявана с помощта на условия, формулирани чрез подходящи предикати. За целта се използва функцията Condition (/;).

Следват две задачи, които могат да бъдат решени елегантно с помощта на разглеждания апарат.

Задача 1. Даден е списък, съставен от поредици от повтарящи се атоми, например

l = {1,1,1,2,2,3,3,3,3,1,1} .

Да се конструира списък от двойки, чиито първи елементи са равни на общите елементи на съответните поредици от списъка l, а вторите им елементи са числа, равни на дължините на тези поредици. В нашия пример търсеният резултат е {{1,3},{2,2},{3,4},{1,2}}.

Решение


l={1,1,1,2,2,3,3,3,3,1,1};

l1=Map[{#,1}&,l]

{{1,1},{1,1},{1,1},{2,1},{2,1},{3,1},{3,1},{3,1},{3,1},

{1,1},{1,1}}

l1//.{x___,{a_,k_},{a_,m_},y___}:>{x,{a,k+m},y}

{{1,3},{2,2},{3,4},{1,2}}

Задача 2. Да се сортира в строго намаляващ ред даден списък от числа, всеки две от които са различни помежду си (например списъкът {2,5,3,1,4}).

Решение


ll={2,5,3,1,4};

ll//.{x___,a_,b_,y___}:>{x,b,a,y}/;a

{5,4,3,2,1}





  1. ЗАКЛЮЧЕНИЕ

Езикът за програмиране на системата Mathematica е изключително богат и в частност предоставя отлични възможности за сравнително изучаване на различни стилове на програмиране чрез демонстрация и анализ на типичните за съответния стил средства за комбиниране и абстракция и характерните за него техники на програмиране. Същевременно могат да бъдат показани и някои специфични за езика на Mathematica особености като например средствата за дефиниране на контекст и оформяне на т. нар. пакети на Mathematica [2].


Благодарности. Настоящата работа е финансирана частично от Националния фонд “Научни изследвания” по проект № И-1002/2000 "Програмни средства за компютърна алгебра, ориентирани към обучението по математика".

ЛИТЕРАТУРА




  1. Бухбергер, Б., Дж. Коллинз, Р. Лоос (ред.). Компьютерная алгебра: Символьные и алгебраические вычисления. Москва, Мир, 1986.

  2. Воробьев, Е. Введение в систему “МАТЕМАТИКА”. Москва, Финансы и статистика, 1998.

  3. Дьяконов, В. Mathematica 4: Учебный курс. Питер, 2001.

  4. Wolfram, S. Mathematica: A System for Doing Mathematics by Computer. Addison-Wesley, 1988.




База данных защищена авторским правом ©obuch.info 2016
отнасят до администрацията

    Начална страница