Module: sage.rings.laurent_series_ring_element
Laurent Series
sage: R.<t> = LaurentSeriesRing(GF(7), 't'); R Laurent Series Ring in t over Finite Field of size 7 sage: f = 1/(1-t+O(t^10)); f 1 + t + t^2 + t^3 + t^4 + t^5 + t^6 + t^7 + t^8 + t^9 + O(t^10)
Laurent series are immutable:
sage: f[2] 1 sage: f[2] = 5 Traceback (most recent call last): ... IndexError: Laurent series are immutable
We compute with a Laurent series over the complex mpfr numbers.
sage: K.<q> = Frac(CC[['q']]) sage: K Laurent Series Ring in q over Complex Field with 53 bits of precision sage: q 1.00000000000000*q
Saving and loading.
sage: loads(q.dumps()) == q True sage: loads(K.dumps()) == K True
IMPLEMENTATION: Laurent series in SAGE are represented internally as a power of the variable times the unit part (which need not be a unit - it's a polynomial with nonzero constant term). The zero Laurent series has unit part 0.
Author Log:
Module-level Functions
) |
) |
Class: LaurentSeries
Functions: add_bigoh,
change_ring,
coefficients,
common_prec,
copy,
degree,
derivative,
exponents,
integral,
is_unit,
is_zero,
list,
power_series,
prec,
shift,
truncate,
truncate_neg,
valuation,
valuation_zero_part,
variable
) |
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = t^2 + t^3 + O(t^10); f t^2 + t^3 + O(t^10) sage: f.add_bigoh(5) t^2 + t^3 + O(t^5)
) |
Return the nonzero coefficients of self.
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = -5/t^(2) + t + t^2 - 10/3*t^3 sage: f.coefficients() [-5, 1, 1, -10/3]
) |
Returns minimum precision of
and self.
sage: R.<t> = LaurentSeriesRing(QQ)
sage: f = t^(-1) + t + t^2 + O(t^3) sage: g = t + t^3 + t^4 + O(t^4) sage: f.common_prec(g) 3 sage: g.common_prec(f) 3
sage: f = t + t^2 + O(t^3) sage: g = t^(-3) + t^2 sage: f.common_prec(g) 3 sage: g.common_prec(f) 3
sage: f = t + t^2 sage: f = t^2 sage: f.common_prec(g) +Infinity
sage: f = t^(-3) + O(t^(-2)) sage: g = t^(-5) + O(t^(-1)) sage: f.common_prec(g) -2
) |
Return the degree of a polynomial equivalent to this power series modulo big oh of the precision.
sage: x = Frac(QQ[['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
) |
The formal derivative of this Laurent series, with respect to variables supplied in args.
Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.
SEE ALSO: self._derivative()
sage: R.<x> = LaurentSeriesRing(QQ) 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) sage: g.derivative(x) -10*x^-11 - 1 + 2*x - 4*x^3 + O(x^7)
sage: R.<t> = PolynomialRing(ZZ) sage: S.<x> = LaurentSeriesRing(R) sage: f = 2*t/x + (3*t^2 + 6*t)*x + O(x^2) sage: f.derivative() -2*t*x^-2 + (3*t^2 + 6*t) + O(x) sage: f.derivative(x) -2*t*x^-2 + (3*t^2 + 6*t) + O(x) sage: f.derivative(t) 2*x^-1 + (6*t + 6)*x + O(x^2)
) |
Return the exponents appearing in self with nonzero coefficients.
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = -5/t^(2) + t + t^2 - 10/3*t^3 sage: f.exponents() [-2, 1, 2, 3]
) |
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(ZZ, '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 cannot be coerced into the base ring
The integral of 1/t is
, which is not given by a Laurent series:
sage: t = Frac(QQ[['t']]).0 sage: f = -1/t^3 - 31/t + O(t^3) sage: f.integral() Traceback (most recent call last): ... ArithmeticError: The integral of is not a Laurent series, since t^-1 has nonzero coefficient.
Another example with just one negative coefficient:
sage: A.<t> = QQ[[]] sage: f = -2*t^(-4) + O(t^8) sage: f.integral() 2/3*t^-3 + O(t^9) sage: f.integral().derivative() == f True
) |
Returns True if this is Laurent series is a unit in this ring.
sage: R.<t> = LaurentSeriesRing(QQ) sage: (2+t).is_unit() True sage: f = 2+t^2+O(t^10); f.is_unit() True sage: 1/f 1/2 - 1/4*t^2 + 1/8*t^4 - 1/16*t^6 + 1/32*t^8 + O(t^10) sage: R(0).is_unit() False sage: R.<s> = LaurentSeriesRing(ZZ) sage: f = 2 + s^2 + O(s^10) sage: f.is_unit() False sage: 1/f Traceback (most recent call last): ... ArithmeticError: division not defined
ALGORITHM: A Laurent series is a unit if and only if its "unit part" is a unit.
) |
sage: x = Frac(QQ[['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
) |
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = -5/t^(2) + t + t^2 - 10/3*t^3 sage: f.list() [-5, 0, 0, 1, 1, -10/3]
) |
sage: R.<t> = LaurentSeriesRing(ZZ) sage: f = 1/(1-t+O(t^10)); f.parent() Laurent Series Ring in t over Integer Ring sage: g = f.power_series(); g 1 + t + t^2 + t^3 + t^4 + t^5 + t^6 + t^7 + t^8 + t^9 + O(t^10) sage: parent(g) Power Series Ring in t over Integer Ring sage: f = 3/t^2 + t^2 + t^3 + O(t^10) sage: f.power_series() Traceback (most recent call last): ... ArithmeticError: self is a not a power series
) |
This function returns the n so that the Laurent series is
of the form (stuff) +
. It doesn't matter how many
negative powers appear in the expansion. In particular,
prec could be negative.
sage: x = Frac(QQ[['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
) |
Returns this laurent series multiplied by the power
. Does not
change this series.
NOTE:
Despite the fact that higher order terms are printed to the
right in a power series, right shifting decreases the powers
of
, while left shifting increases them. This is to be
consistant with polynomials, integers, etc.
sage: R.<t> = LaurentSeriesRing(QQ['y']) sage: f = (t+t^-1)^4; f t^-4 + 4*t^-2 + 6 + 4*t^2 + t^4 sage: f.shift(10) t^6 + 4*t^8 + 6*t^10 + 4*t^12 + t^14 sage: f >> 10 t^-14 + 4*t^-12 + 6*t^-10 + 4*t^-8 + t^-6 sage: t << 4 t^5 sage: t + O(t^3) >> 4 t^-3 + O(t^-1)
Author: Robert Bradshaw (2007-04-18)
) |
Returns the laurent series of degree
which is equivalent to self
modulo
.
) |
Returns the laurent series equivalent to self except without any degree < n terms.
This is equivalent to
.
) |
sage: x = Frac(QQ[['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
) |
sage: x = Frac(QQ[['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.valuation_zero_part() 1 + x + 3*x^3 + O(x^6) sage: g = 1/x^7 - x + x^2 - x^4 + O(x^8) sage: g.valuation_zero_part() 1 - x^8 + x^9 - x^11 + O(x^15)
) |
sage: x = Frac(QQ[['x']]).0 sage: f = 1/x + x^2 + 3*x^4 + O(x^7) sage: f.variable() 'x'
Special Functions: __call__,
__delitem__,
__eq__,
__ge__,
__getitem__,
__getslice__,
__gt__,
__init__,
__iter__,
__le__,
__lshift__,
__lt__,
__ne__,
__neg__,
__normalize,
__pow__,
__reduce__,
__rlshift__,
__rpow__,
__rrshift__,
__rshift__,
__setitem__,
_derivative,
_im_gens_,
_latex_,
_repr_,
_unsafe_mutate
) |
Compute value of this Laurent series at x.
sage: R.<t> = LaurentSeriesRing(ZZ) sage: f = t^(-2) + t^2 + O(t^8) sage: f(2) 17/4 sage: f(-1) 2 sage: f(1/3) 82/9
) |
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = -5/t^(10) + t + t^2 - 10/3*t^3; f -5*t^-10 + t + t^2 - 10/3*t^3 sage: f[-10] -5 sage: f[1] 1 sage: f[3] -10/3 sage: f[-9] 0
) |
Iterate through the coefficients from the first nonzero one to the last nonzero one.
sage: R.<t> = LaurentSeriesRing(QQ) sage: f = -5/t^(2) + t + t^2 - 10/3*t^3; f -5*t^-2 + t + t^2 - 10/3*t^3 sage: for a in f: print a -5 0 0 1 1 -10/3
) |
) |
sage: R.<t> = LaurentSeriesRing(QQ) sage: -(1+t^5) -1 - t^5 sage: -(1/(1+t+O(t^5))) -1 + t - t^2 + t^3 - t^4 + O(t^5)
) |
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
.
) |
) |
) |
The formal derivative of this Laurent series with respect to var.
If var is None or the generator of this ring, it's the formal derivative as expected. Otherwise, _derivative(var) gets called recursively on each coefficient.
SEE ALSO: self.derivative()
sage: x = Frac(QQ[['x']]).0 sage: f = x^2 + 3*x^4 + O(x^7) sage: f._derivative() 2*x + 12*x^3 + O(x^6) sage: f._derivative(x) 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)
Differentiating with respect to something other than the generator gets recursed into the base ring:
sage: R.<t> = PolynomialRing(ZZ) sage: S.<x> = LaurentSeriesRing(R) sage: f = 2*t/x + (3*t^2 + 6*t)*x + O(x^2) sage: f._derivative(t) 2*x^-1 + (6*t + 6)*x + O(x^2)
) |
) |
sage: x = Frac(QQ[['x']]).0 sage: f = (17/2)*x^-2 + x + x^2 + 3*x^4 + O(x^7) sage: latex(f) \frac{\frac{17}{2}}{x^{2}} + x + x^{2} + 3x^{4} + O(x^{7})
) |
sage: R.<t> = LaurentSeriesRing(QQ) sage: (2 + (2/3)*t^3).__repr__() '2 + 2/3*t^3'
) |
SAGE assumes throughout that commutative ring elements are immutable. This is relevant for caching, etc. But sometimes you need to change a Laurent series and you really know what you're doing. That's when this function is for you.
See About this document... for information on suggesting changes.