Предметный указатель

Для удобства интерактивного использования команд пакета Domains используется команда evaldomains [D](expr). evaldomains обеспечивает Maple -подобный пользовательский интерфейс, компоновку данных и проверку типов аргументов Domains -функций. Она вычисляет выражение Maple в домене D и возвращает выражение Maple . Приведем примеры.

Используем введенный нами выше домен С полиномов от одной переменной. Введем два случайных полинома a1 и a2.

> a1:=C[Random]();a2:=C[Random]();

Так выглядит операция перемножения полиномов в Domains - синтаксисе

> C[Output](C[`*`](a1,a2));

Использование знакомого Maple синтаксиса для той же операции при помощи evaldomains

> evaldomains[C](a1*a2);

Если необходимо вычислить несколько выражений в одном и том же домене удобно создать домен-вычислитель с использованием команды создания псевдонимов alias :
alias (dup = evaldomains[домен]):

Так как выражение направляемое на evaldomains вначале обрабатывается синтаксическим анализатором Maple , пользователь не должен забывать о встроенных упрощениях, перегруппировке операндов и вычислении функций верхнего уровня этим анализатором. Например, следующее выражение всегда приводится к 0.
evaldomains[C] (C[Random]() - C[Random]());

Если домен имеет некоммутативное умножение или сложение должна быть использована & -версия оператора с целью предотвращения перегруппировки операндов. Например, используя введенный нами выше домен M3 квадратных матриц 3*3, введем псевдоним

alias (m = evaldomains[M3]);

> A := m (Random());

> m (A &* (A + 1));

8.3.4 Примеры использования пакета Domains

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

> with(Domains);

----------------------- Domains version 1.0 ----------------------

Initially defined domains are Z and Q the integers and rationals

Abbreviations, e.g. DUP for DenseUnivariatePolynomial, also made

Области Z (целых чисел) и Q (рациональных чисел) были определены. Давайте проделаем несколько вычислений

> Z[Gcd](8,12);

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

Что за объекты Z и Q? Z и Q являются таблицами Maple

> type(Z,table);

Они содержат операции (Maple процедуры) для вычислений в Z и Q Какие операции доступны?

> show(Z,operations);

Signatures for constructor Z

note: operations prefixed by -- are not available

* : (Z,Z*) -> Z

* : (Integer,Z) -> Z

+ : (Z,Z*) -> Z

- : (Z,Z) -> Z

- : Z -> Z

0 : Z

1 : Z

< : (Z,Z) -> Boolean

<= : (Z,Z) -> Boolean

<> : (Z,Z) -> Boolean

= : (Z,Z) -> Boolean

> : (Z,Z) -> Boolean

>= : (Z,Z) -> Boolean

Abs : Z -> Z

Characteristic : Integer

Coerce : Integer -> Z

Div : (Z,Z) -> Union(Z,FAIL)

EuclideanNorm : Z -> Integer

Factor : Z -> [Z,[[Z,Integer]*]]

Gcd : Z* -> Z

Gcdex : (Z,Z,Name,Name) -> Z

Gcdex : (Z,Z,Name) -> Z

Input : Expression -> Union(Z,FAIL)

Inv : Z -> Union(Z,FAIL)

Lcm : Z* -> Z

Max : (Z,Z*) -> Z

Min : (Z,Z*) -> Z

Modp : (Z,Z) -> Z

Mods : (Z,Z) -> Z

ModularHomomorphism : () -> (Z -> Z,Z)

Normal : Z -> Z

Output : Z -> Expression

Powmod : (Z,Integer,Z) -> Z

Prime : Z -> Boolean

Quo : (Z,Z,Name) -> Z

Quo : (Z,Z) -> Z

Random : () -> Z

RelativelyPrime : (Z,Z) -> Boolean

Rem : (Z,Z,Name) -> Z

Rem : (Z,Z) -> Z

Sign : Z -> UNION(1,-1,0)

SmallerEuclideanNorm : (Z,Z) -> Boolean

Sqrfree : Z -> [Z,[[Z,Integer]*]]

Type : Expression -> Boolean

Unit : Z -> Z

UnitNormal : Z -> [Z,Z,Z]

Zero : Z -> Boolean

^ : (Z,Integer) -> Z

Давайте выполним некоторые операции в Q[x], то есть в области полиномов от одной переменной над Q. Вначале нужно создать область Q[x], давайте назовем ее C

> C := DenseUnivariatePolynomial(Q,x):

Имя DenseUnivaritePolynomial указывает, что используемая структура данных является плотной. Давайте введем полином

> m := C[Input](x^4-10*x^2+1);

Теперь выведем полином m

> C[Output](m);

Можно вычислить степень полинома.

> C[Degree](m);

Квдрат полинома

> C[`^`](m,2);

Можно вывести случайный полином.

> a := C[Random]();

Каждый домен пакета Domains имеет функцию Random , которая возвращает случайно сгенерированный элемент из домена, который можно использовать для написания примеров. !

> C[Output](a);

Domains может также оперировать с матрицами и другими объектами. Давайте вычислим обратную матрицу к 3на 3 матрице Гильберта. Вначеле мы должны создать матричный домен

> M := SquareMatrix(3,Q):
A := M[Input]([[1,1/2,1/3],[1/2,1/3,1/4],[1/3,1/4,1/5]]);

> M[Det](A);

> M[Inv](A);

Давайте теперь вычислим матрицы полиномов в Q[x]. Будем использовать матрицы 2 на 2, чтобы примеры не получились очень громоздкими.

> M := SquareMatrix(2,C):
A := M[Input]([[x,x^2],[1-x^2,1+x^2]]);

Вычислим определитель матрицы

> C[Output]( M[Det](A) ); # Compute and output det(A)

Вычислим квадрат матрицы

> M[Output]( M[Inv](A));

Error, (in notImplemented) operation is not implemented

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

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

m = x^4-10*x^2+1 . В Maple обычно используется функция RootOf следующим образом

> alias(alpha=RootOf(x^4-10*x^2+1=0,x)):
simplify(1/alpha);

Работая в среде Domains , мы должны создать простое алгебраическое расширение (Simple Algebraic Extension - SAE), используя полином m как минимальный многочлен (minimal polynomial). Итак

> F := SAE(C,m):
a := F[Input](x);

> ai := F[Inv](a);

> F[Output](ai);

Domains обобщается очень естественно для вычислений над F

> M := SquareMatrix(2,F):
A := M[Input]([[1,x],[x^3,x^2]]);

> F[Output]( M[Det](A) );

> M[Output]( M[Inv](A) );

В наших следующих примерах приводятся вычисления со степенными рядами от одной переменной. Вначале давайте создадим домен отложенных степенных рядов от x над Q.

> PS := LazyUnivariatePowerSeries(Q,x):
show(PS,operations);

Signatures for constructor PS

note: operations prefixed by -- are not available

* : (Integer,PS) -> PS

* : (PS,PS*) -> PS

+ : (PS,PS*) -> PS

- : (PS,PS) -> PS

- : PS -> PS

/ : (PS,PS) -> PS

/ : (PS,Integer) -> PS

0 : PS

1 : PS

<> : (PS,PS) -> Boolean

= : (PS,PS) -> Boolean

-- AbsoluteDegree : Integer

Characteristic : Integer

Coeff : (PS,Integer) -> Q

CoefficientRing : Ring

Coerce : Integer -> PS

Constant : Q -> PS

Cos : PS -> Union(PS,FAIL)

Cosh : PS -> Union(PS,FAIL)

Diff : PS -> PS

Div : (PS,PS) -> Union(PS,FAIL)

EuclideanNorm : PS -> Integer

Exp : PS -> Union(PS,FAIL)

Factor : PS -> [PS,[[PS,Integer]*]]

Gcd : PS* -> PS

Gcdex : (PS,PS,Name) -> PS

Gcdex : (PS,PS,Name,Name) -> PS

Input : Expression -> Union(PS,FAIL)

Integrate : PS -> Union(PS,FAIL)

Inv : PS -> PS

Lcm : PS* -> PS

Ln : PS -> Union(PS,FAIL)

Log : PS -> Union(PS,FAIL)

Lorder : PS -> Integer

Monomial : Integer -> PS

Monomial : () -> PS

Normal : PS -> PS

Output : PS -> Expression

Powmod : (PS,Integer,PS) -> PS

Prime : PS -> Boolean

Quo : (PS,PS) -> PS

Quo : (PS,PS,Name) -> PS

R* : (Q,PS) -> PS

R/ : (PS,Q) -> PS

Random : () -> PS

RelativelyPrime : (PS,PS) -> Boolean

Rem : (PS,PS) -> PS

Rem : (PS,PS,Name) -> PS

Series : [[Q,Integer]] -> PS

Shift : (PS,Integer) -> PS

Sin : PS -> Union(PS,FAIL)

Sinh : PS -> Union(PS,FAIL)

SmallerEuclideanNorm : (PS,PS) -> Boolean

Sqrfree : PS -> [PS,[[PS,Integer]*]]

Tan : PS -> Union(PS,FAIL)

Tanh : PS -> Union(PS,FAIL)

Type : Expression -> Boolean

Unit : PS -> PS

UnitNormal : PS -> [PS,PS,PS]

Variable : Name

^ : (PS,Rational) -> PS

^ : (PS,Integer) -> PS

^ : (PS,PS) -> PS

order : PS -> Integer

Давайте вычислим степенной ряд exp(x)

> a := PS[Input](x);

> e := PS[Exp](a);

> PS[`^`](e,3); # exp(x)^3

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

> PS[Output](e,10);

Далее вычислим полиномы Лежандра по их производящей функции:

1/sqrt(1-2*x*t+t^2) = sum( L[n](x)*t^k, k=0.. )
Вначеле создадим домен LUPS == LazyUnivariatePowerSeries.

> P := LUPS(LUPS(Q,x),t):

Вводим выражение

> p := P[Input](1-2*x*t+t^2);

Теперь находим разложение в ряд по t величины p^(-1/2)

> P[`^`](p, -1/2);

Сравним полученную формулу с формулами для полиномов Лежандра, имеющихся в Maple

> seq(orthopoly[P](i,x), i=0..5);

Предметный указатель