# StreamTaylorSeriesOperations A¶

StreamTaylorSeriesOperations implements Taylor series arithmetic, where a Taylor series is represented by a stream of its coefficients.

*: (A, Stream A) -> Stream A

`r * a` returns the power series scalar multiplication of `r` by `a`: `r * [a0, a1, ...] = [r * a0, r * a1, ...]`

*: (Stream A, A) -> Stream A

`a * r` returns the power series scalar multiplication of `a` by `r:` `[a0, a1, ...] * r = [a0 * r, a1 * r, ...]`

*: (Stream A, Stream A) -> Stream A

`a * b` returns the power series (Cauchy) product of `a` and `b:` `[a0, a1, ...] * [b0, b1, ...] = [c0, c1, ...]` where `ck = sum(i + j = k, ai * bk)`.

+: (Stream A, Stream A) -> Stream A

`a + b` returns the power series sum of `a` and `b`: `[a0, a1, ..] + [b0, b1, ..] = [a0 + b0, a1 + b1, ..]`

-: (Stream A, Stream A) -> Stream A

`a - b` returns the power series difference of `a` and `b`: `[a0, a1, ..] - [b0, b1, ..] = [a0 - b0, a1 - b1, ..]`

-: Stream A -> Stream A

`- a` returns the power series negative of `a`: `- [a0, a1, ...] = [- a0, - a1, ...]`

/: (Stream A, Stream A) -> Stream A

`a / b` returns the power series quotient of `a` by `b`. An error message is returned if `b` is not invertible. This function is used in fixed point computations.

addiag: Stream Stream A -> Stream A

`addiag(x)` performs diagonal addition of a stream of streams. if `x` = `[[a<0, 0>, a<0, 1>, ..], [a<1, 0>, a<1, 1>, ..], [a<2, 0>, a<2, 1>, ..], ..]` and `addiag(x) = [b<0, b<1>, ...], then b<k> = sum(i+j=k, a<i, j>)`.

coerce: A -> Stream A

`coerce(r)` converts a ring element `r` to a stream with one element.

compose: (Stream A, Stream A) -> Stream A

`compose(a, b)` composes the power series `a` with the power series `b`.

deriv: Stream A -> Stream A

`deriv(a)` returns the derivative of the power series with respect to the power series variable. Thus `deriv([a0, a1, a2, ...])` returns `[a1, 2 a2, 3 a3, ...]`.

eval: (Stream A, A) -> Stream A

`eval(a, r)` returns a stream of partial sums of the power series `a` evaluated at the power series variable equal to `r`.

evenlambert: Stream A -> Stream A

`evenlambert(st)` computes `f(x^2) + f(x^4) + f(x^6) + ...` if `st` is a stream representing `f(x)`. This function is used for computing infinite products. If `f(x)` is a power series with constant coefficient 1, then `prod(f(x^(2*n)), n=1..infinity) = exp(evenlambert(log(f(x))))`.

exquo: (Stream A, Stream A) -> Union(Stream A, failed)

`exquo(a, b)` returns the power series quotient of `a` by `b`, if the quotient exists, and “failed” otherwise

gderiv: (Integer -> A, Stream A) -> Stream A

`gderiv(f, [a0, a1, a2, ..])` returns `[f(0)*a0, f(1)*a1, f(2)*a2, ..]`.

general_Lambert_product: (Stream A, Integer, Integer) -> Stream A

`general_Lambert_product(f(x), a, d)` returns `f(x^a)*f(x^(a + d))*f(x^(a + 2 d))* ...`. `f(x)` should have constant coefficient equal to one and `a` and `d` should be positive.

generalLambert: (Stream A, Integer, Integer) -> Stream A

`generalLambert(f(x), a, d)` returns `f(x^a) + f(x^(a + d)) + f(x^(a + 2 d)) + ...`. `f(x)` should have zero constant coefficient and `a` and `d` should be positive.

int: A -> Stream A

`int(r)` returns [`r`, `r+1`, `r+2`, …], where `r` is a ring element.

integers: Integer -> Stream Integer

`integers(n)` returns `[n, n+1, n+2, ...]`.

integrate: (A, Stream A) -> Stream A if A has Algebra Fraction Integer

`integrate(r, a)` returns the integral of the power series `a` with respect to the power series variable where `r` denotes the constant of integration. Thus `integrate(a, [a0, a1, a2, ...]) = [a, a0, a1/2, a2/3, ...]`.

invmultisect: (Integer, Integer, Stream A) -> Stream A

`invmultisect(a, b, st)` substitutes `x^((a+b)*n)` for `x^n` and multiplies by `x^b`.

lagrange: Stream A -> Stream A

`lagrange(g)` produces the power series for `f` where `f` is implicitly defined as `f(z) = z*g(f(z))`.

lambert: Stream A -> Stream A

`lambert(st)` computes `f(x) + f(x^2) + f(x^3) + ...` if `st` is a stream representing `f(x)`. This function is used for computing infinite products. If `f(x)` is a power series with constant coefficient 1 then `prod(f(x^n), n = 1..infinity) = exp(lambert(log(f(x))))`.

lazyGintegrate: (Integer -> A, A, () -> Stream A) -> Stream A if A has Field

`lazyGintegrate(f, r, g)` is used for fixed point computations.

lazyIntegrate: (A, () -> Stream A) -> Stream A if A has Algebra Fraction Integer

`lazyIntegrate(r, f)` is a version of integrate used for fixed point computations.

mapdiv: (Stream A, Stream A) -> Stream A if A has Field

`mapdiv([a0, a1, ..], [b0, b1, ..])` returns `[a0/b0, a1/b1, ..]`.

mapmult: (Stream A, Stream A) -> Stream A

`mapmult([a0, a1, ..], [b0, b1, ..])` returns `[a0*b0, a1*b1, ..]`.

monom: (A, Integer) -> Stream A

`monom(deg, coef)` is a monomial of degree `deg` with coefficient coef.

multisect: (Integer, Integer, Stream A) -> Stream A

`multisect(a, b, st)` selects the coefficients of `x^((a+b)*n+a)`, and changes them to `x^n`.

nlde: Stream Stream A -> Stream A if A has Algebra Fraction Integer

`nlde(u)` solves a first order non-linear differential equation described by `u` of the form `[[b<0, 0>, b<0, 1>, ...], [b<1, 0>, b<1, 1>, .], ...]`. the differential equation has the form `y' = sum(i=0 to infinity, j=0 to infinity, b<i, j>*(x^i)*(y^j))`.

oddintegers: Integer -> Stream Integer

`oddintegers(n)` returns `[n, n+2, n+4, ...]`.

oddlambert: Stream A -> Stream A

`oddlambert(st)` computes `f(x) + f(x^3) + f(x^5) + ...` if `st` is a stream representing `f(x)`. This function is used for computing infinite products. If `f`(`x`) is a power series with constant coefficient 1 then `prod(f(x^(2*n-1)), n=1..infinity) = exp(oddlambert(log(f(x))))`.

power: (A, Stream A) -> Stream A if A has Field

`power(a, f)` returns the power series `f` raised to the power `a`.

powern: (Fraction Integer, Stream A) -> Stream A if A has Algebra Fraction Integer

`powern(r, f)` raises power series `f` to the power `r`.

prodiag: Stream Stream A -> Stream A

`prodiag(x)` performs “diagonal” infinite product of a stream of streams. When `x(i)` is interpreted as stream of coefficients of series `f_i(z), i=1,...`, then `prodiag(x) = (1 + z*f_1(z))*(1 + z^2*f_2(x))*...`

recip: Stream A -> Union(Stream A, failed)

`recip(a)` returns the power series reciprocal of `a`, or “failed” if not possible.

revert: Stream A -> Stream A

`revert(a)` computes the inverse of a power series `a` with respect to composition. the series should have constant coefficient 0 and invertible first order coefficient.