Взаимодействия среды

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

Пример 1

Можно создать объекты Series::Puiseux в различных способах. Стандартный метод состоит в том, чтобы использовать конструктора. Второй аргумент задает серийную переменную и точку расширения со значением по умолчанию 0, если не использовано:

Series::Puiseux(x/(1 - x), x);
Series::Puiseux(x/(1 - x), x = 2);
Series::Puiseux(x/(1 - x), x = complexInfinity);

Третий аргумент, если есть задает желаемое количество условий. Если это не использовано, значение переменной окружения, ORDER используется:

Series::Puiseux(x/(1 - x), x = 2, 4);
ORDER := 2:
Series::Puiseux(x/(1 - x), x);
delete ORDER:

Методы const, one и zero обеспечивают ярлыки для создания последовательных расширений только с постоянным термином или никаким ненулевым термином вообще. Определение порядка остаточного члена обязательно:

Series::Puiseux::const(PI, x, 4);
Series::Puiseux::one(x = 2, 3);
Series::Puiseux::zero(x = 0, 3/2);
Series::Puiseux::zero(x = complexInfinity, 5);

Обратите внимание на то, что, например, O(x^(3/2)) не является элементом Series::Puiseux, но может быть преобразован конструктором:

f := O(x^(3/2));
g := Series::Puiseux(f, x);
domtype(f), domtype(g)

И конструктор Series::Puiseux и метод отношение const специальные математические функции, такие как exp или sin, как коэффициенты:

Series::Puiseux(sin(x)/(1 - x), x, 4);
Series::Puiseux::const(cos(x), x = 1, 3);

Используйте системную функцию series, если вы хотите расширить специальные функции также:

series(sin(x)/(1 - x), x, 4);

Конструктор возвращает FAIL, если он не может преобразовать вход в элемент Series::Puiseux. Затем series может смочь произвести более общее расширение:

delete a:
Series::Puiseux(x^a/(1 - x), x);
f := series(x^a/(1 - x), x);
domtype(f);

create метода является чисто синтаксическим конструктором, где операнды заданы явным образом. Шестые и седьмые аргументы являются дополнительными и по умолчанию к 0 и Undirected, соответственно:

Series::Puiseux::create(3, 1, 5, [1/2, 5], x) =
Series::Puiseux::create(3, 1, 5, [1/2, 5], x, 0, Undirected)

Series::Puiseux::create(1, -2, 1, [ln(x), 0, 3], x, complexInfinity);

Пример 2

Мы демонстрируем внутреннюю структуру объектов типа Series::Puiseux:

f := series(exp(x), x = 1);
g := series(sin(sqrt(1/x)), x = infinity);
h := series(sin(sqrt(-x))/x, x = 0)

op(f);
op(g);
op(h)

Серии f и g имеют тип 0, в то время как h имеет тип 1:

op(f, 1), op(g, 1), op(h, 1)

Порядок ветвления f равняется 1, и порядок ветвления и g и h равняется 2:

op(f, 2), op(g, 2), op(h, 2)

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

ldegree(f) = op(f, 3)/op(f, 2),
ldegree(g) = op(g, 3)/op(g, 2),
ldegree(h) = op(h, 3)/op(h, 2);
Series::Puiseux::order(f) = op(f, 4)/op(f, 2),
Series::Puiseux::order(g) = op(g, 4)/op(g, 2),
Series::Puiseux::order(h) = op(h, 4)/op(h, 2);

Для последовательных расширений типа 0 пятый операнд содержит коэффициенты расширения:

op(f, 5) = [coeff(f)];
op(g, 5) = [coeff(g)];

Однако h является расширением типа 1, и затем пятый операнд хранит слагаемых:

op(h, 5);
[coeff(h)];

Шестой операнд содержит серийную переменную и точку расширения:

op(f, 6), Series::Puiseux::indet(f), Series::Puiseux::point(f);
op(g, 6), Series::Puiseux::indet(g), Series::Puiseux::point(g);
op(h, 6), Series::Puiseux::indet(h), Series::Puiseux::point(h);

f расширений и h являются неориентированными, в то время как g является направленным расширением слева вдоль действительной строки к положительной бесконечности:

op(f, 7) = Series::Puiseux::direction(f),
op(g, 7) = Series::Puiseux::direction(g),
op(h, 7) = Series::Puiseux::direction(h);

Пример 3

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

f := x -> arcsin(x + 1):
g := series(f(x), x, 2);
h := series(f(x), x, 2, Right);

Расширение g, типа 1, аппроксимирует f хорошо в открытом диске, сосредоточенном в начале координат. Однако расширение, h, типа 0, требовали для положительных действительных значений x только, и на самом деле это не аппроксимирует f на отрицательной вещественной оси и в верхней полуплоскости:

op(g);
op(h);

DIGITS := 4:
[f(0.01), f(0.01*I), f(-0.01), f(-0.01*I)];
map([g(0.01), g(0.01*I), g(-0.01), g(-0.01*I)], float);
map([h(0.01), h(0.01*I), h(-0.01), h(-0.01*I)], float);
delete DIGITS:

Метод convert01 преобразовывает последовательное расширение типа 0 в один из типа 1:

h1 := Series::Puiseux::convert01(h);
op(h1);

Обратная конверсия, с помощью метода convert10, находится в не всегда возможна:

op(Series::Puiseux::convert10(h1));
op(Series::Puiseux::convert10(g));

Можно осуществить преобразование при помощи свойств:

assume(x > 0):
op(Series::Puiseux::convert10(g));
unassume(x):

Пример 4

Несмотря на имя, элементы Series::Puiseux могут содержать коэффициентные функции в зависимости от серийной переменной:

f := series(psi(x), x = infinity, 4);
domtype(f), coeff(f, 0)

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

diff(f, x) = series(diff(psi(x), x), x = infinity, 4)

int(f, x) = series(int(psi(x), x), x = infinity, 4)

f @ series(2*x, x = infinity) = series(psi(2*x), x = infinity, 4)

Пример 5

Основные арифметические операции реализованы для элементов Series::Puiseux:

f := series(exp(x), x, 4);
g := series(sqrt(x)/(1 - x), x, 4);
h := series(cot(x), x, 4);

f + g + h;
_plus(f, g, h)

f - h = _subtract(f, h);
-g = _negate(g);

f*g*h;
_mult(f, g, h)

f/g = _divide(f, g);
1/h = _invert(h);

Операнды, которые не имеют типа Series::Puiseux, неявно преобразованы в последовательные расширения с той же точкой расширения через конструктора, прежде чем арифметическая операция будет выполнена:

f - 1 - x;
h * (sin(x) + x);

Ошибка происходит, когда точки расширения отличаются, или направления расширения несовместимы:

f := series(arccot(x), x = 0, Left);
g := series(sqrt(sin(x)), x = 0, Right);
f + g

Error: Inconsistent direction. [Series::Puiseux::plus]

h := series(1/x, x = 2, 4);
f * h

Error: Both series must use the same variables and expansion points. [Series::Puiseux::mult]

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

s := series(tanh(x), x, Real);

f + s;
Series::Puiseux::direction(%)

Пример 6

Метод scalmult реализует умножение константой или одним термином:

f := series(1 + 2*x^3, x);
Series::Puiseux::scalmult(f, 5) = 5*f;
Series::Puiseux::scalmult(f, 5, 3) = 5*x^3*f;

g := series(1 + 2*x^3, x = 2, 3);
Series::Puiseux::scalmult(g, 1, 3) = (x - 2)^3*g

h := series(1 + 2*x^3, x = complexInfinity);
Series::Puiseux::scalmult(h, 1, 1/2) = x^(-1/2)*h

Пример 7

Возведение в степень реализовано для интегральных и рациональных экспонент:

f := series(exp(x), x, 3);
f^2 = _power(f, 2);
f^(1/3) = _power(f, 1/3)

Экспонентам позволяют быть нерациональными, если последовательное расширение запускается с постоянного слагаемого, независимого от серийной переменной:

f^I = series(exp(I*x), x, 3);

g := series(sin(-x), x);
g^I

Error: Exponent must be a rational number. [Series::Puiseux::_power]

Если экспонента содержит серийную переменную, то ошибка происходит:

f^x

Error: Exponent must not contain the series variable. [Series::Puiseux::_power]

Для неориентированных расширений и рациональных экспонент, которые не являются неотъемлемой частью, результат имеет тип 1 в целом:

g^(1/2);
op(%, 1);

Результат упрощает, когда вы задаете одно из направлений Left или Right:

g := series(sin(-x), x, Left):
g^(1/2);
op(%, 1);

g := series(sin(-x), x, Right):
g^(1/2);

Пример 8

Функциональный состав элементов Series::Puiseux реализован методом _fconcat:

f := series(ln(x), x = 1, 4);
g := series(cos(y), y = 0);
f@g = _fconcat(f, g);
series(ln(cos(y)), y = 0, 4);

Если левый аргумент не имеет типа Series::Puiseux, это неявно расширено вокруг предельной точки правильного аргумента перед составом:

f := series(sin(-x), x = 0);
sqrt(y) @ f = Series::Puiseux(sqrt(y), y) @ f;

Если правильный аргумент не имеет типа Series::Puiseux, это неявно расширено вокруг источника через конструктора перед составом:

f @ sqrt(y) = f @ Series::Puiseux(sqrt(y), y)

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

f @ tan(y)

f @ series(tan(y), y = 0)

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

g := series(y^2 - 1, y = 0);
f @ g

f @ (y^2 - 1)

f @ series(y^2 - 1, y = 1, 4)

Метод revert вычисляет инверсию усеченного последовательного расширения относительно состава. Точка расширения инверсии является предельной точкой входа и наоборот:

f := series(ln(x), x = 1, 4);
revert(f) = series(exp(x), x = 0, 5)

f := series(cot(x), x = 0);
revert(f) = series(arccot(x), x = complexInfinity);

f @ revert(f), revert(f) @ f

Если серийная переменная происходит в коэффициентах, или флаг типа равняется 1, ошибка происходит:

f := series(ln(sin(x)), x);
g := series(arcsin(x + 1), x, 2);

revert(f)

Error: Unable to compute the functional inverse. [Series::Puiseux::revert]

revert(g)

Error: Unable to compute the functional inverse. [Series::Puiseux::revert]

Пример 9

Методы diff и int реализуют почленное дифференцирование и интегрирование:

f := series(ln(x), x = 1, 4);
g := diff(f, x);
series(1/x, x = 1, 4);
int(g, x);

Если вы задаете область значений интегрирования, то результатом является арифметическое выражение плюс символьный определенный интеграл O - термин:

int(f, x = 1..2);

Пример 10

Большинство специальных математических функций перегружается для Series::Puiseux:

f := series(x/(1 - x), x, 4);
exp(f) = series(exp(x/(1 - x)), x, 4);
ln(f) = series(ln(x/(1 - x)), x, 4);

Если система не может вычислить состав, она возвращает символьный вызов функции с оцененными аргументами:

delete g:
g(f)

exp(series(x + 1/x, x = infinity, 5))

В этом случае можно попробовать series, чтобы вычислить состав:

series(exp(x + 1/x), x = infinity, 5)

Пример 11

Системные функции Re, Im и conjugate работают на все действительные последовательные расширения:

f := series(exp(I*x), x, Real);
Re(f) = series(cos(x), x, Real);
Im(f) = series(sin(x), x, Real) + O(x^6);
conjugate(f) = series(exp(-I*x), x, Real);

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

Re(series(PI, x));
Re(series(exp(I*x), x));

Пример 12

Метод contfrac преобразовывает последовательное расширение в непрерывную дробь:

f := series(exp(x), x, 10);
contfrac(f);

g := series(tan(x), x = PI, 10);
contfrac(g);

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

h := series(ln(x + 1/x), x = infinity);
contfrac(h)

Пример 13

Для последовательных расширений вокруг источника метод laplace, перегружая laplace, вычисляет Преобразование Лапласа почленно, если второй аргумент является серийной переменной. Результатом является последовательное расширение вокруг бесконечности:

delete s:
f := series(exp(x), x);
g := laplace(f, x, s);
series(laplace(exp(x), x, s), s = infinity);

Точно так же ilaplace метода вычисляет обратное Преобразование Лапласа почленно для последовательных расширений вокруг бесконечности, если второй аргумент является серийной переменной. Результатом является последовательное расширение приблизительно 0:

ilaplace(g, s, x)

Преобразование Лапласа и обратное Преобразование Лапласа, соответственно, ряда не целесообразны для точек расширения кроме 0 или бесконечность, соответственно, и в этих случаях возвращен символьный вызов функции:

laplace(series(ln(x), x = 1, 2), x, s);

Если второй аргумент не является серийной переменной, то коэффициенты преобразовываются:

h := series(sin(x*y), x = 1, 2);
laplace(h, y, s);

Пример 14

Когда названо одним аргументом, метод coeff возвращает последовательность всех коэффициентов последовательного расширения:

f := series(tan(x), x);
coeff(f)

g := series(1/(x - 1)^2, x = infinity);
coeff(g)

Когда названо двумя аргументами, coeff возвращает отдельный коэффициент:

coeff(f, -1), coeff(f, 1), coeff(f, 2), coeff(f, 13/2);

Если второй аргумент превышает порядок остаточного члена, coeff возвращает FAIL:

coeff(f, 10)

Когда точкой расширения является complexInfinity, coeff(s, n) возвращает коэффициент, где x является серийной переменной s:

coeff(g, 2), coeff(g, -3), coeff(g, -15/2)

При определении серийной переменной, когда второй или третий аргумент, соответственно, является дополнительным:

coeff(f) = coeff(f, x);
coeff(f, 3) = coeff(f, x, 3)

Для последовательных расширений типа 1 “коэффициенты” в целом включают серийную переменную:

h := series(sin(sqrt(-x)), x);
coeff(h);
coeff(h, 3/2);

Пример 15

Метод ldegree возвращает порядок ведущего срока последовательного расширения. Когда точкой расширения является complexInfinity, и ведущий термин, затем это - n:

f := series(x*sin(sqrt(-x)), x);
g := series(cot(x), x = PI);
h := series(2*arccot(x), x = infinity);

ldegree(f), ldegree(g), ldegree(h)

Метод lcoeff возвращает коэффициент ведущего термина. Для расширения типа 1 это обычно включает серийную переменную:

lcoeff(f), lcoeff(g), lcoeff(h)

Метод lterm возвращает сам ведущий термин:

lterm(f), lterm(g), lterm(h)

Наконец, метод lmonomial возвращает целое слагаемое:

lmonomial(f) = lcoeff(f)*lterm(f);
lmonomial(g) = lcoeff(g)*lterm(g);
lmonomial(h) = lcoeff(h)*lterm(h);

Если последовательное расширение состоит только из O - термин, все четыре метода возвращают FAIL:

s := Series::Puiseux::zero(x, 6);
ldegree(s), lcoeff(s), lterm(s), lmonomial(s)

Пример 16

Методы nthcoeff, nthmonomial и nthterm возвращают n th ненулевой коэффициент, одночлен или термин, соответственно, последовательного расширения. В отличие от полиномов, они рассчитывают от термина самых низкоуровневых на, т.е. упорядоченное расположение возрастает экспонентой для конечных точек расширения и убывает экспонентой, когда точкой расширения является complexInfinity:

f := series(x*sin(sqrt(-x)), x);
g := series(cot(x), x = PI);
h := series(2*arccot(x), x = infinity);

nthcoeff(f, 1) = lcoeff(f);
nthmonomial(g, 1) = lmonomial(g);
nthterm(h, 1) = lterm(h);

nthcoeff(f, 3), nthmonomial(f, 3), nthterm(f, 3);
nthcoeff(g, 3), nthmonomial(g, 3), nthterm(g, 3);
nthcoeff(h, 3), nthmonomial(h, 3), nthterm(h, 3);

Если второй аргумент не положителен или превышает количество ненулевых слагаемых, все три метода возвращают FAIL:

nthcoeff(f, -4), nthterm(g, 0), nthmonomial(h, 4)

Пример 17

Мы иллюстрируем различие между упорядоченным расположением условий в последовательными расширениями и полиномах. Упорядоченное расположение условий в полиноме согласовывает с упорядоченным расположением условий в последовательном расширении с точкой расширения complexInfinity:

f := poly(2*(x^2 + x)^3);
g := series(f, x = complexInfinity);
[lcoeff(f), lmonomial(f), lterm(f)];
[lcoeff(g), lmonomial(g), lterm(g)];

[nthcoeff(f, 2), nthmonomial(f, 3), nthterm(f, 4)];
[nthcoeff(g, 2), nthmonomial(g, 3), nthterm(g, 4)];

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

h := series(f, x = 0);  
[lcoeff(h), lmonomial(h), lterm(h)];
[nthcoeff(h, 2), nthmonomial(h, 3), nthterm(h, 4)];

Пример 18

iszero метода проверяет, не имеет ли последовательное расширение никаких ненулевых слагаемых кроме O - термин:

f := series(exp(x), x);
g := Series::Puiseux(0, x = 2, 4);
iszero(f), iszero(g)

Пример 19

Методы convert пытаются преобразовать произвольный объект в элемент Series::Puiseux. Если вход не предлагает точку расширения, convert использует источник:

f := asympt(1/(x + 1), x = infinity);
g := sin(x)/(1 - x);
h := poly((x + 1)^10);
u := O((x - 1)^3, x = 1);

domtype(f), domtype(g), domtype(h), domtype(u)

F := Series::Puiseux::convert(f);
G := Series::Puiseux::convert(g);
H := Series::Puiseux::convert(h);
U := Series::Puiseux::convert(u);

convert возвращает FAIL, если это не может преобразовать вход, например, потому что вход содержит не или больше чем один неопределенный:

Series::Puiseux::convert(sin(1)),
Series::Puiseux::convert([1, y, 3])

Метод convert_to пытается преобразовать элемент Series::Puiseux в заданный тип:

Series::Puiseux::convert_to(F, Series::gseries);
Series::Puiseux::convert_to(F, contfrac);
Series::Puiseux::convert_to(G, DOM_EXPR);
Series::Puiseux::convert_to(H, DOM_POLY);
Series::Puiseux::convert_to(H, O);
Series::Puiseux::convert_to(U, O);

convert_to возвращает FAIL, если это не может выполнить требуемое преобразование:

Series::Puiseux::convert_to(F, O),
Series::Puiseux::convert_to(F, DOM_LIST)

Пример 20

Метод expr преобразовывает элемент Series::Puiseux в арифметическое выражение, отбрасывая O - термин. В целом упорядоченное расположение слагаемых не сохраняется:

f := series(exp(x*y), x);
g := series(ln(x), x = 1, 3);

expr(f);
expr(g);

Метод float применяет системную функцию float ко всем коэффициентам:

float(f);
float(g);

Пример 21

Методы combine, expand и normal применяют соответствующие системные функции ко всем коэффициентам:

delete a, y:
f := series(y/(x + y^a), x, 4);
g := combine(f);
expand(g);

По причинам эффективности арифметические методы Series::Puiseux обычно не выполняют символьных упрощений. Используйте expand или normal, чтобы упростить результаты:

h := series(exp(x), x, 4)^a;
expand(h);
normal(h);

u := series(arctanh(x + y), x, 4);
normal(u);

Помимо нормализации коэффициентов, метод normal также удаляет продвижение и конечные нули из списка коэффициентов:

v := Series::Puiseux::create(1, 3, 10,
                             [0, 1/2, 0, 5, 0, 0], x, 2);
coeff(v);
normal(v);
coeff(%);

Метод map применяет заданную функцию ко всем коэффициентам. Например, системная функция, factor не перегружается для Series::Puiseux, но можно использовать map, чтобы выразить все коэффициенты в учтенной форме:

map(u, factor);

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

w := series(exp(x), x, 3);
map(w, _mult, PI) = PI*w

Для последовательных расширений типа 1 map применяет функцию ко всем ненулевым коэффициентам, как возвращено coeff:

z := series(sin(sqrt(-x)), x);
coeff(z);
map(z, cos);

Пример 22

Три различных метода могут использоваться, чтобы заменить серийную переменную: _fconcat, func_call и subs. Предположим, что f является элементом Series::Puiseux, и мы хотим заменить выражением t серийную переменную x. Затем _fconcat преобразовывает t в последовательное расширение вокруг источника через конструктора, вычисляет функциональный состав и возвращает результат как элемент Series::Puiseux:

f := series(exp(x), x = 0, 5);
Series::Puiseux::_fconcat(f, y) = f @ y;
f @ (y^2 + y);

Состав может перестать работать, если предельная точка t вокруг источника отличается от точки расширения f или если t содержит специальные математические функции:

f @ (y + 1);

f @ sin(y);

Кроме того, состав не работает, если выражение t является постоянным или содержит больше чем один неопределенный:

f @ PI;

Error: Unable to compute composition. [Series::Puiseux::_fconcat]

f @ (x + y);

Error: Unable to compute composition. [Series::Puiseux::_fconcat]

Можно осуществить состав путем явного преобразования t в ряд:

f @ series(y + 1, y = -1);
f @ series(sin(y), y = 0);
f @ series(x + y, x = -y);

Замена с func_call всегда работает. Это отбрасывает остаточный член, t заменяют буквально, и результатом является выражение и не объект типа Series::Puiseux:

f(5) = Series::Puiseux::func_call(f, 5);
f(y) = Series::Puiseux::func_call(f, y);

f(y^2 + y);
f(y + 1);
f(sin(y));
f(PI);
f(x + y);

Наконец, если subs используется, чтобы заменить серийную переменную, только совершенно особые замены позволены (см. описание subs выше для получения дополнительной информации). Затем замена переменной выполняется, и результат снова имеет тип Series::Puiseux:

subs(f, x = y^2 + y)

Error: Invalid substitution. [Series::Puiseux::subs]

subs(f, x = y + 1)

subs(f, x = sin(y))

Error: Invalid substitution. [Series::Puiseux::subs]

subs(f, x = PI)

Error: Invalid substitution. Exactly one indeterminate expected. [Series::Puiseux::subs]

subs(f, x = x + y)

Error: Invalid substitution. Exactly one indeterminate expected. [Series::Puiseux::subs]

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

s := series(ln(x^2 + x), x);
s @ (2*y);
s(2*y);
subs(s, x = 2*y);

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

g := series(cos(x + y), x, 4);
h := series(1/x, x = y, 4);

subs(g, y = PI) = series(cos(x + PI), x, 4);
subs(h, y = 2) = series(1/x, x = 2, 4);

Даже одновременные замены возможны в коэффициентах:

subs(g, [hold(sin) = cos, hold(cos) = sin, y = 2])

Ошибка происходит, если правая сторона содержит серийную переменную:

subs(h, y = x)

Error: Invalid substitution. Right side must not contain the series variable. [Series::Puiseux::subs]

Пример 23

Проверки has метода, происходит ли объект синтаксически в коэффициентах, серийной переменной, точке расширения или направлении элемента Series::Puiseux:

f := series(sin(x + 2*y), x = PI, 2);
has(f, x), has(f, y), has(f, PI), has(f, 2), has(f, Undirected);
has(f, hold(sin)), has(f, 3), has(f, sin(2*y)), has(f, x - PI);

Последняя возможность возвращает FALSE начиная с выражения, x - PI происходит только на экране вывод, но не на внутреннем представлении f.

g := series(sign(x), x, Right);
has(g, Right), has(g, Undirected);

Пример 24

Метод truncate отбрасывает слагаемых до данного распоряжения:

f := series(x*sin(sqrt(x)), x);
Series::Puiseux::truncate(f, 10);
Series::Puiseux::truncate(f, 9/2);
Series::Puiseux::truncate(f, 7/2);
Series::Puiseux::truncate(f, 3);
Series::Puiseux::truncate(f, 3/2);
Series::Puiseux::truncate(f, 1);

Возвращаемые значения

объект доменного типа Series::Puiseux или значение FAIL, если f не может быть преобразован, например, если степени с нерациональными экспонентами происходят в f.

Вызовы функции

При вызове элемента Series::Puiseux, когда функция отбрасывает остаточный член и заменяет первым аргументом серийную переменную. См. описание метода "func_call" и Пример 22.

Операции

Series::Puiseux реализует основную арифметику усеченных последовательных расширений. Используйте обычные арифметические операторы +, -, *, /, ^ и @ для состава.

Арифметические методы Series::Puiseux обычно не выполняют символьных упрощений. Используйте combine, expand или normal, чтобы запросить такие упрощения явным образом.

Смотрите пример 5 и пример 21.

Специальные математические функции, такие как exp или sin, перегружаются для элементов Series::Puiseux; cf. Пример 10.

Системные функции coeff, lcoeff, nthcoeff, ldegree, lmonomial, nthmonomial, lterm и nthterm работают над усеченными последовательными расширениями. Обратите внимание на то, что в отличие от полиномов, коэффициенты, одночлены и условия считаются от термина термина самого низкоуровневого на. Cf. Пример 17.

Используйте функциональный expr, чтобы преобразовать последовательное расширение на арифметическое выражение (как элемент области ядра).

Операнды

Серия доменного типа Series::Puiseux имеет следующие семь операндов:

Флаг типа различает два различных внутренних представления.

Если t = 0, то операнды выше представляют усеченное последовательное расширение

Если точка расширения, x ₀ является complexInfinity, то операнды представляют усеченное расширение

Если t = 1, то операнды выше представляют расширение

В этом случае степени x - x ₀ явным образом хранится в списке и l_{, i} содержит только условия порядка роста. Соответствующее расширение для x0 = complexInfinity

и l _i содержит только условия порядка роста.

Термин понятий и порядок эквивалентны для t = 0, слагаемое l_{, i} называется одночленом, и соответствующий коэффициент

(или

соответственно).

Последний тип представления служит для правильных расширений вокруг точек разветвления. Например, если мы хотим расшириться вокруг x = 0, затем усеченный ряд Пюизе не аппроксимирует f (x) в более низкой половине комплексной плоскости. С t = 1, расширение, которое аппроксимирует f (x) также в более низкой части комплексной плоскости около источника, может быть представлено как объект доменного типа Series::Puiseux.

Направление d имеет то же значение как параметр dir конструктора. Если d = Undirected, операнды выше представляют расширение, допустимое в некотором окружении точки расширения в комплексной плоскости. Обычно, это - открытый диск, сосредоточенный в x0. Если d ≠ Undirected и x ₀ представляет вещественное число, это означает, что расширение допустимо для действительных значений x только. Если d = Left или d = Right, то расширение допустимо для x <x ₀ или x> x ₀, соответственно.

В случае x_0 = complexInfinity, и если d = Undirected, у нас есть расширение, допустимое в окружении Северного полюса Римановой сферы, т.е. для всего достаточно большого абсолютного значения. Если d = Left, у нас есть расширение вокруг положительной действительной бесконечности, допустимой для достаточно больших действительных значений x. Точно так же, если d = Right, у нас есть расширение вокруг отрицательной действительной бесконечности, допустимой для достаточно больших отрицательных действительных значений x. Наконец, если d = Real, расширение допустимо и вокруг infinity и вокруг - ∞.

Cf. Пример 2.

Создание элемента

Как правило, объекты типа Series::Puiseux сгенерированы вызовами series или taylor.