15.4 Laurent Series

Module: sage.rings.laurent_series_ring_element

Author Log:

Class: LaurentSeries

class LaurentSeries
LaurentSeries( self, parent, f, [n=0])

Create the Laurent series $ t^n \cdot f$ . The default is n=0.

INPUT:
    parent -- a Laurent series ring
    f -- a power series (or something can be coerced to one)
    n -- integer (default 0)

OUTPUT:
    a Laurent series

sage: K, q = Frac(C[['q']]).objgen()
sage: K
Laurent Series Ring in q over Complex Field with 53 bits of precision
sage: q
1.0000000000000000*q

Saving and loading.

sage: loads(q.dumps()) == q
True
sage: loads(K.dumps()) == K
True

Functions: add_bigoh,$  $ copy,$  $ degree,$  $ derivative,$  $ integral,$  $ is_zero,$  $ power_series,$  $ prec,$  $ unit_part,$  $ valuation,$  $ variable

degree( self)

Return the degree of a polynomial equivalent to this power series modulo big oh of the precision.

sage: x = Frac(Q[['x']]).0
sage: g = x^2 - x^4 + O(x^8)
sage: g.degree()
4
sage: g = -10/x^5 + x^2 - x^4 + O(x^8)
sage: g.degree()
4

derivative( self)

The formal derivative of this Laurent series.

sage: x = Frac(Q[['x']]).0
sage: f = x^2 + 3*x^4 + O(x^7)
sage: f.derivative()
2*x + 12*x^3 + O(x^6)
sage: g = 1/x^10 - x + x^2 - x^4 + O(x^8)
sage: g.derivative()
-10*x^-11 - 1 + 2*x - 4*x^3 + O(x^7)

integral( self)

The formal integral of this Laurent series with 0 constant term.

The integral may or may not be defined if the base ring is not a field.

sage: t = LaurentSeriesRing(Z, 't').0
sage: f = 2*t^-3 + 3*t^2 + O(t^4)
sage: f.integral()
-t^-2 + t^3 + O(t^5)

sage: f = t^3
sage: f.integral()
Traceback (most recent call last):
...
ArithmeticError: Coefficients of integral of t^3 cannot be coerced into the
base ring

The integral of 1/t is $ \log(t)$ , which is not given by a Laurent series:

sage: t = Frac(Q[['t']]).gen()
sage: f = -1/t^3 - 31/t + O(t^3)
sage: f.integral()
Traceback (most recent call last):
...
ArithmeticError: The integral of -t^-3 - 31*t^-1 + O(t^3) is not a Laurent
series, since t^-1 has nonzero coefficient -31.

is_zero( self)

sage: x = Frac(Q[['x']]).0
sage: f = 1/x + x + x^2 + 3*x^4 + O(x^7)
sage: f.is_zero()
0
sage: z = 0*f
sage: z.is_zero()
1

prec( self)

This function returns the n so that the Laurent series is of the form (stuff) + $ O(t^n)$ . It doesn't matter how many negative powers appear in the expansion. In particular, prec could be negative.

sage: x = Frac(Q[['x']]).0
sage: f = x^2 + 3*x^4 + O(x^7)
sage: f.prec()
7
sage: g = 1/x^10 - x + x^2 - x^4 + O(x^8)
sage: g.prec()
8

unit_part( self)

sage: x = Frac(Q[['x']]).0
sage: f = x + x^2 + 3*x^4 + O(x^7)
sage: f/x
1 + x + 3*x^3 + O(x^6)
sage: f.unit_part()
1 + x + 3*x^3 + O(x^6)
sage: g = 1/x^7 - x + x^2 - x^4 + O(x^8)
sage: g.unit_part()
1 - x^8 + x^9 - x^11 + O(x^15)

valuation( self)

sage: x = Frac(Q[['x']]).0
sage: f = 1/x + x^2 + 3*x^4 + O(x^7)
sage: g = 1 - x + x^2 - x^4 + O(x^8)
sage: f.valuation()
-1
sage: g.valuation()
0

variable( self)

sage: x = Frac(Q[['x']]).0
sage: f = 1/x + x^2 + 3*x^4 + O(x^7)
sage: f.variable()
'x'

Special Functions: __add__,$  $ __call__,$  $ __div__,$  $ __getitem__,$  $ __getslice__,$  $ __iter__,$  $ __mul__,$  $ __neg__,$  $ __pow__,$  $ __repr__,$  $ __setitem__,$  $ __sub__,$  $ _cmp_,$  $ _im_gens_,$  $ _latex_,$  $ _LaurentSeries__normalize

__add__( self, right)

sage: x = Frac(Q[['x']]).0
sage: f = 1/x^10 + x + x^2 + 3*x^4 + O(x^7)
sage: g = 1 - x + x^2 - x^4 + O(x^8)
sage: f*g
x^-10 - x^-9 + x^-8 - x^-6 + O(x^-2)

__call__( self, x)

Compute value of this Laurent series at x.

sage: t = LaurentSeriesRing(Z, 't').0
sage: f = t^(-2) + t^2 + O(t^8)
sage: f(2)
17/4
sage: f(-1)
2
sage: f(1/3)
82/9

__div__( self, right)

sage: x = Frac(Q[['x']]).0
sage: f = x + x^2 + 3*x^4 + O(x^7)
sage: g = 1/x^7 - x + x^2 - x^4 + O(x^8)
sage: f/x
1 + x + 3*x^3 + O(x^6)
sage: f/g
x^8 + x^9 + 3*x^11 + O(x^14)

__mul__( self, right)

sage: x = Frac(Q[['x']]).0
sage: f = 1/x^3 + x + x^2 + 3*x^4 + O(x^7)
sage: g = 1 - x + x^2 - x^4 + O(x^8)
sage: f*g
x^-3 - x^-2 + x^-1 + 4*x^4 + O(x^5)

__pow__( self, right)

sage: x = Frac(Q[['x']]).0
sage: f = x + x^2 + 3*x^4 + O(x^7)
sage: g = 1/x^10 - x + x^2 - x^4 + O(x^8)
sage: f^7
x^7 + 7*x^8 + 21*x^9 + 56*x^10 + 161*x^11 + 336*x^12 + O(x^13)
sage: g^7
x^-70 - 7*x^-59 + 7*x^-58 - 7*x^-56 + O(x^-52)

_cmp_( self, right)

sage: x = Frac(Q[['x']]).0
sage: f = x + x^2 + 3*x^4 + O(x^7)
sage: g = 1/x^7 - x + x^2 - x^4 + O(x^8)
sage: f<g
False
sage: f>g
True

_latex_( self)

sage: x = Frac(Q[['x']]).0
sage: f = (17/2)*x^-2 + x + x^2 + 3*x^4 + O(x^7)
sage: f._latex_()
'\frac{17}{2}x^{-2} + x + x^{2} + 3x^{4} + \cdots'

_LaurentSeries__normalize( self)

A Laurent series is a pair (u(t), n), where either u=0 (to some precision) or u is a unit. This pair corresponds to $ t^n\cdot u(t)$ .

See About this document... for information on suggesting changes.