Составные математические объекты

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

1. последовательности (exprseq)

> s:= 1,4,9,25;

> t:= sin, cos, tan;

> whattype(s);

Пустая последовательность обозначается NULL. Последовательности ассоциативны, т.е. складываются

> s:=1,(4,9,16),25;

> t:=s,s;

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

> s:=seq( i^2, i=1..5 );

С другой стороны

> s:=NULL; for i from 1 to 5 do s:=s,i^2 od;

Как видим, цикл работает медленее и занимает больше памяти. Другие примеры:

> seq( x[i], i=1..5 );

> a:=38*x^2+y*x-11;

> seq(coeff(a,x,i),i=0..degree(a,x));

> seq(D(f),f=[sin,cos,tan,exp,ln]);

2. множества ( set )

> s:={x,1,1-z,x};

> whattype(s);

Как мы видим, в множестве не может быть одинаковых элементов. Пустое множество обозначается {}. Для работы с множествами используют команды union, intersect, minus:

> {a,b} union {b,c};

> {a,b} intersect {b,c};

> {a,b} minus {b,c};

> a union b union a;

> {3,4} union a union {3,7};

> `union`({3,4},a,{3,7});

3. списки ( list )

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

> List:=[x,1,1-z,x];

> whattype(List);

> [x,y,y];

> [y,x,y];

Заметим, что это разные списки! Для создания списков и множеств можно использовать команду seq, это эффективнее, чем применение циклов.

> L := [seq(x[i],i=1..4)];

> L[2];

Для добавления элемента в список

> L := [op(L),x[5]];

Для выделения части списка

> L[-3..-2];

Для сокращения списка (выбрасываем второй элемент)

> L := subsop(2=NULL,L);

Список также может состоять из списков

> L:=[[1,2],[3,4,5]];

Элементами множеств и списков могут быть так же сами множества или списки.

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

· member

· has

· convert

> member(y, {x, y, z});

> member(y, {x*y, y*z});

> member(x*y, [x*y, w+u, y]);

> member(w, [x, y, w, u], 'k'); k;

В последнем примере мы присвоили переменной k номер элемента w в данном списке. Аналог данной команды для выражений:

> f := (a+b^3+c)^(4/3);

> has( f, a );

> has( f, b^3 );

> has( f, b^2 );

> has( f, a+b^3+c );

> has( f, a+c );

> has( f, {c,d} );

> has( f, {d,e} );

Оператор преобразования

> convert( [1,2,3,4], `+` );

> f := seq( x[i]^i, i=1..4 );

> convert([f], `*`);

Команды ввода и вывода

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

Пример 7 (команда save и некоторые другие).

Переменные x,y,z записываются в файл name.ext командой

> save x, y, z, `name.ext`:

Соответственно для ввода данных используют команду

> read `name.ext`

Если Вы хотите записать все результаты в файл, используйте команды writeto(filename), appendto(filename) или writedata, writestat, writebytes, writeline. Можно печатать результаты в файл или на экран. Для этого служат команды print, lprint и printf - печать по формату. Как обычно, при этом надо файл открыть и закрыть open, close (и это не единственные команды данного типа).

Перед тем, как записывать данные, Вы их можете конвертировать convert к необходимому Вам виду.

Для удобства, можно непосредственно переписать все в формате следующих языков: Си, Фортран и LaTeX (например, смотри fortran[procedure]).

Если Вы хотите использовать Maple для анализа и графичекой интерпретации числовой информации, то Вам потребуется считывать данные из других файлов. Для этих целей служит набор команд read, readline, readdata, readstat, readbytes, fscanf, parse.

Дифференцирование

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

1. (a+b)'=a'+b' - дифференцирование суммы,

2. (a b)'=a' b+a b' - дифференцирование произведения,

3. (a / b)'=(a' b-a b') / b^2 - дифференцирование отношения,

4. f(g(x))'=f ' (g(x)) g'(x) - дифференцирование сложной функции,

позволяет нам продифференцировать произвольную функцию.

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

Алгоритм дифференцирования достаточно прост и, поэтому, попробуем реализовать этот алгоритм для дифференцирования полиномов от одной переменной

P = a[n]*x^n + a[n-1]*x^(n-1) + ... + a[0]

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

Итак, для того чтобы продифференцировать полином нам надо:

1. отличать в выражении P переменную x от коэффициентов a[k] и показателей степеней n;

2. различать математические операции - сумму, произведение и степень;

3. задать правила дифференцирования.

Начнем с выделения различных частей выражения. В Maple для этих целей служит команда op(i,e) которая выделяет имя (операнд) под номером i из выражения e. Общее число операндов в выражении определяется командой nop(e).

Пример 1 ( команды op - nop).

> v := f(x,y,z);

> nops(v);

> op(0,v);

> op(2,v);

Более сложный пример

> w := f(g(a,b),h(c,d));

> op(1,op(2,w));

> op([2,1],w);

> op([-1,-1],w);

Таким образом можно выделять более сложные части выражений.

> s := series(sin(x),x=2,6);

> op(0,s);

В последнем примере мы разложили функцию sin(x) в окрестности точки x=2 с точностью O( x^6 ).

Далее нам надо научиться определять тип переменных и выражений. Для этого используется логическая команда type(e,t) где e - выражение, а t - имя типа выражения. В ответе получаем либо "правда", либо "ложь". Типов выражений очень много и из простых типов можно составлять составные типы. Заметим, что команда whattype(e), которая должна выдавать тип выражения значительно уступает команде type по своим возможностям. Рассмотрим несколько примеров.

Пример 2 ( типы выражений и переменных).

> type( 2, integer );

> type( a + b, `+` );

> type( a * b, `+` );

> type( a and b, `and` );

Это простые типы, рассмотрим составные

> type(x^(-2),name^integer);

> type(x^(-2),name^posint);

> type(x^(-2),algebraic^integer);

> type(x+y^(1/2)+1,`&+`(name,radical,integer));

> type(a*b*c,`&*`(algebraic,algebraic,algebraic));

> type(exp(x),exp(name));

> type([x,1],[name,integer]);

Так как type булевская команда, то изучим сразу же условный оператор if вида

if условие a then выполняемое выражение A

elif условие b then выполняемое выражение B

else выполняемое выражение C

Эта конструкция дает возможность в зависимости от условий a и b выполнять выражения A, B или C, в качестве которых может выступать любая последовательность Maple-команд.

Пример 3 (условный оператор).

> a := 3; b := 5;

> if (a > b) then a else b fi;

Более сложная конструкция

> 5*(Pi + `if`(a > b,a,b));

Теперь можно написать программу (процедуру) дифференцирования полиномов. Процедуры в Maple начинаются со слова proc и заканчиваются словом end. Текст процедуры может находиться в любом месте программы. После загрузки процедуры в рабочую память ее вызов осуществляется по имени. По умолчанию возвращаемым значением является значение последнего оператора из тела процедуры.

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

Пример 4 (процедура дифференцирования полиномов).

> df:=proc(p:algebraic,x:name) local u,v;

> if type(p,numeric) then 0

> elif type(p,name) then

> if p=x then 1 else 0 fi

> elif type(p,`+`) then map (df,p,x)

> elif type(p,`*`) then

> u:=op(1,p); v:=p/u;

> df(u,x)*v+df(v,x)*u

> elif type(p,anything^integer) then

> u:=op(1,p); v:=op(2,p);

> v*df(u,x)*u^(v-1)

> else ERROR(`Ошибка при дифференцировании полинома`,p)

> fi

> end:

Разберем структуру процедуры.

В первой строке мы определяем имя процедуры, типы входных данных p и x и вводим две внутренних переменных u,v (это можно сделать и по умолчанию).

Во второй строке задано правило: производная от числа (тип numeric) есть ноль.

В третьей строке задано правило: производная от переменной (тип name) есть dx / dx =1 или dy / dx=0.

В четвертой строке задано правило 1 о дифференцировании суммы (тип `+`). Для дифференцирования слагаемых применяется таже процедура df, к которой мы обращаемся реккурсивно, используя команду map (данная команда позволяет применить процедуру df ко всем слагаемым сразу).

В пятой строке задано правило 2 о дифференцировании произведения (тип `*`). Для дифференцирования множителей, которым присваиваются имена u и v, применяется процедура df . (в отличие от предыдущей строки мы вынуждены делать это явно)

В шестой строке задано правило дифференцирования степени переменной (тип anything^integer), при этом мы так же явно выделяем части выражения.

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

Теперь можно продифференцировать что нибудь

> g:=y^5+x*y^4+z*y^3;

Ø df(g,y);