Ticket #11726: trac_11726.patch

File trac_11726.patch, 45.9 KB (added by boothby, 10 years ago)
  • sage/algebras/iwahori_hecke_algebra.py

    # HG changeset patch
    # Parent 2a2abbcad325ccca9399981ceddf5897eb467e64
    
    diff -r 2a2abbcad325 sage/algebras/iwahori_hecke_algebra.py
    a b  
    384384            sage: [V1,V2]=H1.algebra_generators()
    385385            sage: [W1,W2]=H1.inverse_generators()
    386386            sage: [W1,W2]
    387             [(q^-1)*V1 + (-1+q^-1), (q^-1)*V2 + (-1+q^-1)]
     387            [(q^-1)*V1 + (q^-1-1), (q^-1)*V2 + (q^-1-1)]
    388388            sage: V1*W1, W2*V2
    389389            (1, 1)
    390390
     
    524524                sage: H = IwahoriHeckeAlgebraT("A2",q)
    525525                sage: [T1,T2]=H.algebra_generators()
    526526                sage: x = (T1*T2).inverse(); x
    527                 (q^-2)*T2*T1 + (-q^-1+q^-2)*T1 + (-q^-1+q^-2)*T2 + (1-2*q^-1+q^-2)
     527                (q^-2)*T2*T1 + (q^-2-q^-1)*T1 + (q^-2-q^-1)*T2 + (q^-2-2*q^-1+1)
    528528                sage: x*T1*T2
    529529                1
    530530
  • sage/categories/pushout.py

    diff -r 2a2abbcad325 sage/categories/pushout.py
    a b  
    13771377                  Defn: x |--> x + 2*y
    13781378                        y |--> 3*x - y
    13791379        sage: F(f)(x*F(P).gen()^-2+y*F(P).gen()^3)
    1380         (3*x - y)*t^3 + (x + 2*y)*t^-2
     1380        (x + 2*y)*t^-2 + (3*x - y)*t^3
    13811381
    13821382    """
    13831383    rank = 9
  • sage/combinat/kazhdan_lusztig.py

    diff -r 2a2abbcad325 sage/combinat/kazhdan_lusztig.py
    a b  
    4242            sage: R.<q>=LaurentPolynomialRing(QQ)
    4343            sage: KL=KazhdanLusztigPolynomial(W,q)
    4444            sage: KL.P(s2,s3*s2*s3*s1*s2)
    45             q + 1
     45            1 + q
    4646
    4747        """
    4848        self._coxeter_group = W
     
    128128                return 0
    129129        p = sum(-self.R(x,t)*self.P(t,y) for t in self._coxeter_group.bruhat_interval(x,y) if t != x)
    130130        tr = floor((y.length()-x.length()+1)/2)
    131         try:
    132             ret = p.truncate(tr)
    133         except:
    134             ret = laurent_polynomial_truncate(p, tr)
     131        ret = p.truncate(tr)
    135132        if self._trace:
    136133            print "    P(%s,%s)=%s"%(x, y, ret)
    137134        return ret
    138        
    139 def laurent_polynomial_truncate(p, n):
    140     """
    141     Truncates the Laurent polynomial p, returning only terms
    142     of degree <n, similar to the truncate method for polynomials.
    143135
    144     EXAMPLES ::
    145 
    146         sage: from sage.combinat.kazhdan_lusztig import laurent_polynomial_truncate
    147         sage: P.<q> = LaurentPolynomialRing(QQ)
    148         sage: laurent_polynomial_truncate((q+q^-1)^3+q^2*(q+q^-1)^4,3)
    149         6*q^2 + 3*q + 4 + 3*q^-1 + q^-2 + q^-3
    150     """
    151     pdict = p._dict()
    152     dict = {}
    153     for k in pdict:
    154         if k[0] < n:
    155             dict[k] = pdict[k]
    156     return p.parent()(dict)
    157 
    158    
    159    
  • sage/rings/laurent_series_ring.py

    diff -r 2a2abbcad325 sage/rings/laurent_series_ring.py
    a b  
    2828
    2929
    3030laurent_series = {}
    31 def LaurentSeriesRing(base_ring, name=None, names=None, sparse=False):
     31def LaurentSeriesRing(base_ring, name=None, names=None, sparse=False, default_prec=None):
    3232    """
    3333    EXAMPLES::
    3434   
     
    9494    else:
    9595        raise TypeError, "base_ring must be a commutative ring"
    9696    laurent_series[key] = weakref.ref(R)
     97    if default_prec is not None:
     98        R.set_default_prec(default_prec)
    9799    return R
    98100
    99101def is_LaurentSeriesRing(x):
     
    178180            sage: I = sqrt(-1)
    179181            sage: K.<I> = QQ[I]
    180182            sage: P.<t> = PolynomialRing(K)
    181             sage: L.<u> = LaurentSeriesRing(QQ[I])
     183            sage: L.<u> = LaurentSeriesRing(QQ[I], default_prec = 20)
    182184            sage: L((t*I)/(t^3+I*2*t))
    183185            1/2 + 1/4*I*u^2 - 1/8*u^4 - 1/16*I*u^6 + 1/32*u^8 +
    184186            1/64*I*u^10 - 1/128*u^12 - 1/256*I*u^14 + 1/512*u^16 +
     
    217219        from sage.rings.fraction_field_element import is_FractionFieldElement
    218220        from sage.rings.polynomial.polynomial_element import is_Polynomial
    219221        from sage.rings.polynomial.multi_polynomial_element import is_MPolynomial
    220        
     222
    221223        if isinstance(x, laurent_series_ring_element.LaurentSeries) and n==0 and self is x.parent():
    222224            return x  # ok, since Laurent series are immutable (no need to make a copy)
    223225        elif isinstance(x, pari_gen):
  • sage/rings/laurent_series_ring_element.pyx

    diff -r 2a2abbcad325 sage/rings/laurent_series_ring_element.pyx
    a b  
    6363import sage.misc.latex
    6464import sage.rings.ring_element as ring_element
    6565from sage.rings.integer import Integer
     66from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial_univariate
    6667
    6768from sage.structure.element cimport Element, ModuleElement, RingElement, AlgebraElement
    6869
     
    118119        """
    119120        AlgebraElement.__init__(self, parent)
    120121
    121         if PY_TYPE_CHECK(f, LaurentSeries):
     122        if isinstance(f, LaurentSeries):
    122123            n += (<LaurentSeries>f).__n
    123124            if (<LaurentSeries>f).__u._parent is parent.power_series_ring():
    124125                f = (<LaurentSeries>f).__u
    125126            else:
    126127                f = parent.power_series_ring()((<LaurentSeries>f).__u)
    127         elif not PY_TYPE_CHECK(f, PowerSeries):
     128        elif isinstance(f, LaurentPolynomial_univariate):
     129            f = f(parent.gen())
     130        elif not isinstance(f, PowerSeries):
    128131            f = parent.power_series_ring()(f)
    129132        ## now this is a power series, over a different ring ...
    130133        ## requires that power series rings with same vars over the
     
    685688       
    686689    def shift(self, k):
    687690        r"""
    688         Returns this laurent series multiplied by the power `t^n`.
     691        Returns this Laurent series multiplied by the power `t^n`.
    689692        Does not change this series.
    690693       
    691694        .. note::
  • sage/rings/polynomial/laurent_polynomial.pxd

    diff -r 2a2abbcad325 sage/rings/polynomial/laurent_polynomial.pxd
    a b  
    44from sage.rings.polynomial.multi_polynomial cimport MPolynomial
    55from sage.rings.polynomial.polynomial_element cimport Polynomial
    66
     7
     8cdef class LaurentPolynomial_univariate(CommutativeAlgebraElement):
     9    cpdef ModuleElement __u
     10    cdef long __n
     11
    712cdef class LaurentPolynomial_mpair(CommutativeAlgebraElement):
    813    cdef ETuple _mon
    914    cdef MPolynomial _poly
  • sage/rings/polynomial/laurent_polynomial.pyx

    diff -r 2a2abbcad325 sage/rings/polynomial/laurent_polynomial.pyx
    a b  
    33"""
    44include "../../ext/stdsage.pxi"
    55
    6 import re
     6#from infinity import infinity
    77from sage.rings.integer import Integer
    88from sage.structure.element import is_Element
    99from sage.misc.latex import latex
     10import sage.misc.latex
    1011from sage.misc.misc import union
    1112from sage.structure.factorization import Factorization
     13from sage.misc.derivative import multi_derivative
     14from sage.rings.polynomial.polynomial_element import Polynomial
     15from sage.rings.laurent_series_ring_element import LaurentSeries
    1216
     17cdef class LaurentPolynomial_univariate(CommutativeAlgebraElement):
     18    """
     19    Univariate Laurent Polynomial
     20
     21    AUTHORS::
     22
     23        Tom Boothby (2011) copied this class almost verbatim from
     24        laurent_series_ring_element.pyx, so most of the credit goes to
     25        William Stein, David Joyner, and Robert Bradshaw
     26
     27    """
     28
     29
     30    def __init__(self, parent, f, n=0):
     31        r"""
     32        Create the Laurent polynomial `t^n \cdot f`. The default is
     33        n=0.
     34       
     35        INPUT:
     36       
     37       
     38        -  ``parent`` - a Laurent polynomial ring
     39       
     40        -  ``f`` - a polynomial (or something can be coerced to one)
     41       
     42        -  ``n`` - integer (default 0)
     43       
     44       
     45        OUTPUT: a Laurent polynomial
     46       
     47        EXAMPLES::
     48       
     49            sage: R.<q> = LaurentPolynomialRing(ZZ)
     50            sage: R([1,2,3])
     51            1 + 2*q + 3*q^2
     52       
     53        ::
     54       
     55            sage: S.<s> = LaurentPolynomialRing(GF(5))
     56            sage: T.<t> = PolynomialRing(pAdicRing(5))
     57            sage: S(t)
     58            s
     59            sage: parent(S(t))
     60            Univariate Laurent Polynomial Ring in s over Finite Field of size 5
     61            sage: parent(S(t)[1])
     62            Finite Field of size 5
     63        """
     64
     65        CommutativeAlgebraElement.__init__(self, parent)
     66
     67        if isinstance(f, LaurentPolynomial_univariate):
     68            n += (<LaurentPolynomial_univariate>f).__n
     69            if (<LaurentPolynomial_univariate>f).__u._parent is parent.polynomial_ring():
     70                f = (<LaurentPolynomial_univariate>f).__u
     71            else:
     72                f = parent.polynomial_ring()((<LaurentPolynomial_univariate>f).__u)
     73        elif (not isinstance(f, Polynomial)) or (parent is not f.parent()):
     74            if isinstance(f, dict):
     75                v = min(f.keys())
     76                f = dict((i-v,c) for i,c in f.items())
     77                n+=v
     78            f = parent.polynomial_ring()(f)
     79       
     80
     81        # self is that t^n * u:
     82        cdef long val
     83        self.__u = f
     84        self.__n = n
     85        self.__normalize()
     86
     87    def __reduce__(self):
     88        return make_element_from_parent, (self._parent, self.__u, self.__n)
     89       
     90    def change_ring(self, R):
     91        """
     92        Return a copy of this Laurent polynomial, with coefficients in R.
     93
     94        EXAMPLES::
     95
     96            sage: R.<x> = LaurentPolynomialRing(QQ)
     97            sage: a = x^2 + 3*x^3 + 5*x^-1
     98            sage: a.change_ring(GF(3))
     99            2*x^-1 + x^2
     100
     101        """
     102
     103        return self.parent().change_ring(R)(self)
     104
     105    def is_unit(self):
     106        """
     107        Returns True if this Laurent polynomial is a unit in this ring.
     108       
     109        EXAMPLES::
     110       
     111            sage: R.<t> = LaurentPolynomialRing(QQ)
     112            sage: (2+t).is_unit()
     113            False
     114            sage: f = 2*t
     115            sage: f.is_unit()
     116            True
     117            sage: 1/f
     118            1/2*t^-1
     119            sage: R(0).is_unit()
     120            False
     121            sage: R.<s> = LaurentPolynomialRing(ZZ)
     122            sage: g = 2*s
     123            sage: g.is_unit()
     124            False
     125            sage: 1/g
     126            Traceback (most recent call last):
     127            ...
     128            ArithmeticError: division not defined
     129       
     130        ALGORITHM: A Laurent polynomial is a unit if and only if its "unit
     131        part" is a unit.
     132        """
     133        return self.__u.is_monomial() and self.__u.coefficients()[0].is_unit()
     134
     135    def is_zero(self):
     136        """
     137        EXAMPLES::
     138       
     139            sage: R.<x> = LaurentPolynomialRing(QQ)
     140            sage: f = 1/x + x + x^2 + 3*x^4
     141            sage: f.is_zero()
     142            0
     143            sage: z = 0*f
     144            sage: z.is_zero()
     145            1
     146        """
     147        return self.__u.is_zero()
     148       
     149    def __nonzero__(self):
     150        return not not self.__u
     151       
     152    def _im_gens_(self, codomain, im_gens):
     153        return codomain(self(im_gens[0]))
     154
     155    def __normalize(self):
     156        r"""
     157        A Laurent series is a pair (u(t), n), where either u=0 (to some
     158        precision) or u is a unit. This pair corresponds to
     159        `t^n\cdot u(t)`.
     160        """
     161        from sage.rings.infinity import infinity
     162        if self.is_zero():
     163            return
     164        v = self.__u.valuation()
     165        if v == 0:
     166            return
     167        if v != infinity:
     168            self.__n += v
     169            self.__u = self.__u >> v
     170
     171    def _repr_(self):
     172        """
     173        EXAMPLES::
     174       
     175            sage: R.<t> = LaurentPolynomialRing(QQ)
     176            sage: (2 + (2/3)*t^3).__repr__()
     177            '2 + 2/3*t^3'
     178        """
     179        if self.is_zero():
     180            return "0"
     181        s = " "
     182        v = self.__u.list()
     183        valuation = self.__n
     184        m = len(v)
     185        X = self._parent.variable_name()
     186        atomic_repr = self._parent.base_ring().is_atomic_repr()
     187        first = True
     188        for n in xrange(m):
     189            x = v[n]
     190            e = n + valuation
     191            x = str(x)
     192            if x != '0':
     193                if not first:
     194                    s += " + "
     195                if not atomic_repr and (x[1:].find("+") != -1 or x[1:].find("-") != -1):
     196                    x = "(%s)"%x
     197                if e == 1:
     198                    var = "*%s"%X
     199                elif e == 0:
     200                    var = ""
     201                else:
     202                    var = "*%s^%s"%(X,e)
     203                s += "%s%s"%(x,var)
     204                first = False
     205        s = s.replace(" + -", " - ")
     206        s = s.replace(" 1*"," ")
     207        s = s.replace(" -1*", " -")
     208        return s[1:]
     209
     210    def _latex_(self):
     211        r"""
     212        EXAMPLES::
     213       
     214            sage: R.<x> = LaurentPolynomialRing(QQ)
     215            sage: f = (17/2)*x^-2 + x + x^2 + 3*x^4
     216            sage: latex(f)
     217            \frac{\frac{17}{2}}{x^{2}} + x + x^{2} + 3x^{4}
     218
     219        Verify that trac #6656 has been fixed::
     220
     221            sage: R.<a,b>=PolynomialRing(QQ)
     222            sage: T.<x>=LaurentPolynomialRing(R)
     223            sage: y = a*x+b*x
     224            sage: y._latex_()
     225            '\\left(a + b\\right)x'
     226            sage: latex(y)
     227            \left(a + b\right)x
     228        """
     229        if self.is_zero():
     230            return "0"
     231        s = " "
     232        v = self.__u.list()
     233        valuation = self.__n
     234        m = len(v)
     235        X = self._parent.latex_variable_names()[0]
     236        atomic_repr = self._parent.base_ring().is_atomic_repr()
     237        first = True
     238        for n in xrange(m):
     239            x = v[n]
     240            e = n + valuation
     241            x = sage.misc.latex.latex(x)
     242            if x != '0':
     243                if not first:
     244                    s += " + "
     245                if not atomic_repr and e > 0 and (x[1:].find("+") != -1 or x[1:].find("-") != -1):
     246                    x = "\\left(%s\\right)"%x
     247                if e == 1:
     248                    var = "|%s"%X
     249                elif e == 0:
     250                    var = ""
     251                elif e > 0:
     252                    var = "|%s^{%s}"%(X,e)
     253                if e >= 0:
     254                    s += "%s%s"%(x,var)
     255                else: # negative e
     256                    if e == -1:
     257                        s += "\\frac{%s}{%s}"%(x, X)
     258                    else:
     259                        s += "\\frac{%s}{%s^{%s}}"%(x, X,-e)
     260                first = False
     261        s = s.replace(" + -", " - ")
     262        s = s.replace(" 1|"," ")
     263        s = s.replace(" -1|", " -")
     264        s = s.replace("|","")
     265
     266        return s[1:]
     267       
     268    def __hash__(self):
     269        return hash(self.__u) ^ self.__n
     270
     271    def __getitem__(self, i):
     272        """
     273        EXAMPLES::
     274       
     275            sage: R.<t> = LaurentPolynomialRing(QQ)
     276            sage: f = -5/t^(10) + t + t^2 - 10/3*t^3; f
     277            -5*t^-10 + t + t^2 - 10/3*t^3
     278            sage: f[-10]
     279            -5
     280            sage: f[1]
     281            1
     282            sage: f[3]
     283            -10/3
     284            sage: f[-9]
     285            0
     286        """
     287        return self.__u[i-self.__n]
     288
     289    def __getslice__(self, i, j):
     290        """
     291        EXAMPLES::
     292       
     293            sage: R.<t> = LaurentPolynomialRing(QQ)
     294            sage: f = -5/t^(10) + 1/3 + t + t^2 - 10/3*t^3; f
     295            -5*t^-10 + 1/3 + t + t^2 - 10/3*t^3
     296            sage: f[-10:2]
     297            -5*t^-10 + 1/3 + t
     298            sage: f[0:]
     299            1/3 + t + t^2 - 10/3*t^3
     300        """
     301        if j > self.__u.degree():
     302            j = self.__u.degree()
     303        f = self.__u[i-self.__n:j-self.__n]
     304        return LaurentPolynomial_univariate(self._parent, f, self.__n)
     305
     306    def __iter__(self):
     307        """
     308        Iterate through the coefficients from the first nonzero one to the
     309        last nonzero one.
     310       
     311        EXAMPLES::
     312       
     313            sage: R.<t> = LaurentPolynomialRing(QQ)
     314            sage: f = -5/t^(2) + t + t^2 - 10/3*t^3; f
     315            -5*t^-2 + t + t^2 - 10/3*t^3
     316            sage: for a in f: print a
     317            -5
     318            0
     319            0
     320            1
     321            1
     322            -10/3
     323        """
     324        return iter(self.__u)
     325
     326    def dict(self):
     327        """
     328        Return a dictionary representing self.
     329
     330        EXAMPLES::
     331            sage: R.<x,y> = ZZ[]
     332            sage: Q.<t> = LaurentPolynomialRing(R)
     333            sage: f = (x^3 + y/t^3)^3 + t^2; f
     334            y^3*t^-9 + 3*x^3*y^2*t^-6 + 3*x^6*y*t^-3 + x^9 + t^2
     335            sage: f.dict()
     336            {0: x^9, -6: 3*x^3*y^2, 2: 1, -3: 3*x^6*y, -9: y^3}
     337
     338        """
     339
     340        return dict(zip(self.exponents(), self.coefficients()))
     341
     342    def coefficients(self):
     343        """
     344        Return the nonzero coefficients of self.
     345       
     346        EXAMPLES::
     347       
     348            sage: R.<t> = LaurentPolynomialRing(QQ)
     349            sage: f = -5/t^(2) + t + t^2 - 10/3*t^3
     350            sage: f.coefficients()
     351            [-5, 1, 1, -10/3]
     352        """
     353        return self.__u.coefficients()
     354
     355    def exponents(self):
     356        """
     357        Return the exponents appearing in self with nonzero coefficients.
     358       
     359        EXAMPLES::
     360       
     361            sage: R.<t> = LaurentPolynomialRing(QQ)
     362            sage: f = -5/t^(2) + t + t^2 - 10/3*t^3
     363            sage: f.exponents()
     364            [-2, 1, 2, 3]
     365        """
     366        return [i+self.__n for i in self.__u.exponents()]
     367
     368    def __setitem__(self, n, value):
     369        """
     370        EXAMPLES::
     371       
     372            sage: R.<t> = LaurentPolynomialRing(QQ)
     373            sage: f = t^2 + t^3
     374            sage: f[2] = 5
     375            Traceback (most recent call last):
     376            ...
     377            IndexError: Laurent polynomials are immutable
     378        """
     379        raise IndexError, "Laurent polynomials are immutable"
     380
     381    def _unsafe_mutate(self, i, value):
     382        """
     383        Sage assumes throughout that commutative ring elements are
     384        immutable. This is relevant for caching, etc. But sometimes you
     385        need to change a Laurent polynomial and you really know what you're
     386        doing. That's when this function is for you.
     387       
     388        EXAMPLES:
     389        """
     390        j = i - self.__n
     391        if j >= 0:
     392            self.__u._unsafe_mutate(j, value)
     393        else: # off to the left
     394            if value != 0:
     395                self.__n = self.__n + j
     396                R = self._parent.base_ring()
     397                coeffs = [value] + [R(0) for _ in range(1,-j)] + self.__u.list()
     398                self.__u = self.__u._parent(coeffs)
     399        self.__normalize()
     400
     401    cpdef ModuleElement _add_(self, ModuleElement right_m):
     402        """
     403        Add two Laurent polynomials with the same parent.
     404       
     405        EXAMPLES::
     406       
     407            sage: R.<t> = LaurentPolynomialRing(QQ)
     408            sage: t + t
     409            2*t
     410            sage: f = 1/t + t^2 + t^3 - 17/3 * t^4
     411            sage: g = 2/t + t^3
     412            sage: f + g
     413            3*t^-1 + t^2 + 2*t^3 - 17/3*t^4
     414            sage: f + 0
     415            t^-1 + t^2 + t^3 - 17/3*t^4
     416            sage: 0 + f
     417            t^-1 + t^2 + t^3 - 17/3*t^4
     418            sage: R(0) + R(0)
     419            0
     420            sage: t^3 + t^-3
     421            t^-3 + t^3
     422       
     423        ALGORITHM: Shift the unit parts to align them, then add.
     424        """
     425        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_m
     426        cdef long m
     427       
     428        # 1. Special case when one or the other is 0.
     429        if not right:
     430            return self
     431        if not self:
     432            return right
     433
     434        # 2. Align the unit parts.
     435        if self.__n < right.__n:
     436            m = self.__n
     437            f1 = self.__u
     438            f2 = right.__u << right.__n - m
     439        elif self.__n > right.__n:
     440            m = right.__n
     441            f1 = self.__u << self.__n - m
     442            f2 = right.__u
     443        else:
     444            m = self.__n
     445            f1 = self.__u
     446            f2 = right.__u
     447        # 3. Add
     448        return LaurentPolynomial_univariate(self._parent, f1 + f2, m)
     449       
     450    cpdef ModuleElement _iadd_(self, ModuleElement right_m):
     451        """
     452        EXAMPLES::
     453       
     454            sage: R.<t> = LaurentPolynomialRing(QQ)
     455            sage: f = t+t
     456            sage: f += t; f
     457            3*t
     458            sage: f += t*t; f
     459            3*t + t^2
     460        """
     461        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_m
     462        if self.__n == right.__n:
     463            self.__u += right.__u
     464            return self
     465        else:
     466            return self._add_(right)
     467
     468    cpdef ModuleElement _sub_(self, ModuleElement right_m):
     469        """
     470        Subtract two Laurent polynomials with the same parent.
     471       
     472        EXAMPLES::
     473       
     474            sage: R.<t> = LaurentPolynomialRing(QQ)
     475            sage: t - t
     476            0
     477            sage: t^5 + 2 * t^-5
     478            2*t^-5 + t^5
     479       
     480        ALGORITHM: Shift the unit parts to align them, then subtract.
     481        """
     482        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_m
     483        cdef long m
     484
     485        # 1. Special case when one or the other is 0.
     486        if not right:
     487            return self
     488        if not self:
     489            return -right
     490
     491        # 2. Align the unit parts.
     492        if self.__n < right.__n:
     493            m = self.__n
     494            f1 = self.__u
     495            f2 = right.__u << right.__n - m
     496        else:
     497            m = right.__n
     498            f1 = self.__u << self.__n - m
     499            f2 = right.__u
     500        # 3. Subtract
     501        return LaurentPolynomial_univariate(self._parent, f1 - f2, m)
     502
     503
     504#    def add_bigoh(self, prec):
     505#        """
     506#        EXAMPLES::
     507#       
     508#            sage: R.<t> = LaurentPolynomialRing(QQ)
     509#            sage: f = t^2 + t^3 + O(t^10); f
     510#            t^2 + t^3 + O(t^10)
     511#            sage: f.add_bigoh(5)
     512#            t^2 + t^3 + O(t^5)
     513#        """
     514#        if prec == infinity:
     515#            return self
     516#        u = self.__u.add_bigoh(prec - self.__n)
     517#        return LaurentSeries(self._parent.completion(self._parent.gen()), u, self.__n)
     518
     519    def degree(self):
     520        """
     521        Return the degree of this polynomial.
     522       
     523        EXAMPLES::
     524       
     525            sage: R.<x> = LaurentPolynomialRing(ZZ)
     526            sage: g = x^2 - x^4
     527            sage: g.degree()
     528            4
     529            sage: g = -10/x^5 + x^2 - x^7
     530            sage: g.degree()
     531            7
     532        """
     533        return self.__u.degree() + self.__n
     534
     535
     536    def __neg__(self):
     537        """
     538        ::
     539       
     540            sage: R.<t> = LaurentPolynomialRing(ZZ)
     541            sage: -(1+t^5)
     542            -1 - t^5
     543
     544        """
     545        return LaurentPolynomial_univariate(self._parent, -self.__u, self.__n)
     546
     547    cpdef RingElement _mul_(self, RingElement right_r):
     548        """
     549        EXAMPLES::
     550       
     551            sage: R.<x> = LaurentPolynomialRing(GF(2))
     552            sage: f = 1/x^3 + x + x^2 + 3*x^4
     553            sage: g = 1 - x + x^2 - x^4
     554            sage: f*g
     555            x^-3 + x^-2 + x^-1 + x^8
     556        """
     557        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_r
     558        return LaurentPolynomial_univariate(self._parent,
     559                             self.__u * right.__u,
     560                             self.__n + right.__n)
     561                             
     562    cpdef RingElement _imul_(self, RingElement right_r):
     563        """
     564        EXAMPLES::
     565       
     566            sage: R.<x> = LaurentPolynomialRing(ZZ)
     567            sage: f = 1/x^3 + x + x^2 + 3*x^4
     568            sage: g = 1 - x + x^2 - x^4
     569            sage: f *= g; f
     570            x^-3 - x^-2 + x^-1 + 4*x^4 - 4*x^5 + 2*x^6 - 3*x^8
     571        """
     572        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_r
     573        self.__u *= right.__u
     574        self.__n += right.__n
     575        return self
     576                             
     577    cpdef ModuleElement _rmul_(self, RingElement c):
     578        return LaurentPolynomial_univariate(self._parent, self.__u._rmul_(c), self.__n)
     579                             
     580    cpdef ModuleElement _lmul_(self, RingElement c):
     581        return LaurentPolynomial_univariate(self._parent, self.__u._lmul_(c), self.__n)
     582                             
     583    cpdef ModuleElement _ilmul_(self, RingElement c):
     584        self.__u *= c
     585        return self
     586                             
     587    def __pow__(_self, r, dummy):
     588        """
     589        EXAMPLES::
     590       
     591            sage: x = LaurentPolynomialRing(QQ,'x').0
     592            sage: f = x + x^2 + 3*x^4
     593            sage: g = 1/x^10 - x
     594            sage: f^3
     595            x^3 + 3*x^4 + 3*x^5 + 10*x^6 + 18*x^7 + 9*x^8 + 27*x^9 + 27*x^10 + 27*x^12
     596            sage: g^4
     597            x^-40 - 4*x^-29 + 6*x^-18 - 4*x^-7 + x^4
     598        """
     599        cdef LaurentPolynomial_univariate self = _self
     600        right=int(r)
     601        if right != r:
     602            raise ValueError, "exponent must be an integer"
     603        return LaurentPolynomial_univariate(self._parent, self.__u**right, self.__n*right)
     604       
     605    def shift(self, k):
     606        r"""
     607        Returns this Laurent polynomial multiplied by the power `t^n`.
     608        Does not change this polynomial.
     609       
     610        .. note::
     611
     612           Despite the fact that higher order terms are printed to the
     613           right in a power series, right shifting decreases the
     614           powers of `t`, while left shifting increases
     615           them. This is to be consistent with polynomials, integers,
     616           etc.
     617       
     618        EXAMPLES::
     619       
     620            sage: R.<t> = LaurentPolynomialRing(QQ['y'])
     621            sage: f = (t+t^-1)^4; f
     622            t^-4 + 4*t^-2 + 6 + 4*t^2 + t^4
     623            sage: f.shift(10)
     624            t^6 + 4*t^8 + 6*t^10 + 4*t^12 + t^14
     625            sage: f >> 10
     626            t^-14 + 4*t^-12 + 6*t^-10 + 4*t^-8 + t^-6
     627            sage: t << 4
     628            t^5
     629
     630        """
     631        return LaurentPolynomial_univariate(self._parent, self.__u, self.__n + k)       
     632       
     633    def __lshift__(LaurentPolynomial_univariate self, k):
     634        return LaurentPolynomial_univariate(self._parent, self.__u, self.__n + k)
     635
     636    def __rshift__(LaurentPolynomial_univariate self, k):
     637        return LaurentPolynomial_univariate(self._parent, self.__u, self.__n - k)
     638       
     639    cpdef RingElement _div_(self, RingElement right_r):
     640        """
     641        EXAMPLES::
     642       
     643            sage: R.<x> = LaurentPolynomialRing(QQ)
     644            sage: f = x + x^2 + 3*x^4
     645            sage: g = 1/x^7 - x + x^2 - x^4
     646            sage: f/x
     647            1 + x + 3*x^3
     648            sage: f/g
     649            Traceback (most recent call last):
     650            ...
     651            ArithmeticError: division not defined
     652        """
     653        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_r
     654        if right.__u.is_zero():
     655            raise ZeroDivisionError
     656        try:
     657            return LaurentPolynomial_univariate(self._parent,
     658                             self.__u / right.__u,
     659                             self.__n - right.__n)
     660        except TypeError, msg:
     661            # todo: this could also make something in the formal fraction field.
     662            raise ArithmeticError, "division not defined"
     663
     664
     665    def __richcmp__(left, right, int op):
     666        return (<Element>left)._richcmp(right, op)
     667
     668    cdef int _cmp_c_impl(self, Element right_r) except -2:
     669        r"""
     670        Comparison of self and right.
     671       
     672        EXAMPLES::
     673       
     674            sage: R.<x> = LaurentPolynomialRing(QQ)
     675            sage: f = x^(-1) + 1 + x
     676            sage: g = x^(-1) + 1
     677            sage: f == g
     678            False
     679       
     680        ::
     681       
     682            sage: f = x^(-1) + 1 + x
     683            sage: g = x^(-1) + 2
     684            sage: f == g
     685            False
     686            sage: f < g
     687            True
     688            sage: f > g
     689            False
     690       
     691        ::
     692       
     693            sage: f = x^(-2) + 1 + x
     694            sage: g = x^(-1) + 2
     695            sage: f == g
     696            False
     697            sage: f < g
     698            False
     699            sage: f > g
     700            True
     701        """
     702        cdef LaurentPolynomial_univariate right = <LaurentPolynomial_univariate>right_r
     703
     704        zero = self.base_ring()(0)
     705       
     706        if not self and not right:
     707            if self.__n < right.__n:
     708                return cmp(self.__u[0], zero)
     709            elif self.__n > right.__n:
     710                return cmp(zero, right.__u[0])
     711           
     712        # zero pad coefficients on the left, to line them up for comparison
     713        cdef long n = min(self.__n, right.__n)       
     714        x = [zero] * (self.__n - n) + self.__u.list()
     715        y = [zero] * (right.__n - n) + right.__u.list()
     716
     717        # zero pad on right to make the lists the same length
     718        # (this is necessary since the power series list() function just
     719        # returns the coefficients of the underlying polynomial, which may
     720        # have zeroes in the high coefficients)
     721        if len(x) < len(y):
     722            x.extend([zero] * (len(y) - len(x)))
     723        elif len(y) < len(x):
     724            y.extend([zero] * (len(x) - len(y)))
     725
     726        return cmp(x,y)
     727
     728    def valuation_zero_part(self):
     729        """
     730        EXAMPLES::
     731       
     732            sage: R.<x> = LaurentPolynomialRing(QQ)
     733            sage: f = x + x^2 + 3*x^4
     734            sage: f/x
     735            1 + x + 3*x^3
     736            sage: f.valuation_zero_part()
     737            3*x^3 + x + 1
     738            sage: g = 1/x^7 - x + x^2 - x^4
     739            sage: g.valuation_zero_part()
     740            -x^11 + x^9 - x^8 + 1
     741        """
     742        return self.__u
     743
     744    def valuation(self):
     745        """
     746        EXAMPLES::
     747       
     748            sage: R.<x> = LaurentPolynomialRing(ZZ)
     749            sage: f = 1/x + x^2 + 3*x^4
     750            sage: g = 1 - x + x^2 - x^4
     751            sage: f.valuation()
     752            -1
     753            sage: g.valuation()
     754            0
     755        """
     756        return self.__n
     757
     758    def truncate(self, n):
     759        """
     760        Return a polynomial with degree at most `n-1` whose `j`-th coefficients
     761        agree with self for all `j<n`.
     762       
     763        EXAMPLES::
     764
     765            sage: R.<x> = LaurentPolynomialRing(QQ)
     766            sage: f = 1/x^12 + x^3 + x^5 + x^9
     767            sage: f.truncate(10)
     768            x^-12 + x^3 + x^5 + x^9
     769            sage: f.truncate(5)
     770            x^-12 + x^3
     771            sage: f.truncate(-16)
     772            0
     773        """
     774        if n <= self.valuation():
     775            return self._parent(0)
     776        else:
     777            return LaurentPolynomial_univariate(self._parent, self.__u.truncate(n-self.__n), self.__n)
     778
     779
     780    def variable(self):
     781        """
     782        EXAMPLES::
     783       
     784            sage: R.<x> = LaurentPolynomialRing(QQ)
     785            sage: f = 1/x + x^2 + 3*x^4
     786            sage: f.variable()
     787            'x'
     788        """
     789        return self._parent.variable_name()
     790
     791    def __copy__(self):
     792        return LaurentPolynomial_univariate(self._parent, self.__u.copy(), self.__n)
     793
     794
     795    def derivative(self, *args):
     796        """
     797        The formal derivative of this Laurent polynomial, with respect
     798        to variables supplied in args.
     799       
     800        Multiple variables and iteration counts may be supplied; see
     801        documentation for the global derivative() function for more
     802        details.
     803       
     804        .. seealso::
     805
     806           :meth:`_derivative`
     807       
     808        EXAMPLES::
     809       
     810            sage: R.<x> = LaurentPolynomialRing(QQ)
     811            sage: g = 1/x^10 - x + x^2 - x^4
     812            sage: g.derivative()
     813            -10*x^-11 - 1 + 2*x - 4*x^3
     814            sage: g.derivative(x)
     815            -10*x^-11 - 1 + 2*x - 4*x^3
     816       
     817        ::
     818       
     819            sage: R.<t> = PolynomialRing(ZZ)
     820            sage: S.<x> = LaurentPolynomialRing(R)
     821            sage: f = 2*t/x + (3*t^2 + 6*t)*x
     822            sage: f.derivative()
     823            -2*t*x^-2 + (3*t^2 + 6*t)
     824            sage: f.derivative(x)
     825            -2*t*x^-2 + (3*t^2 + 6*t)
     826            sage: f.derivative(t)
     827            2*x^-1 + (6*t + 6)*x
     828        """
     829        return multi_derivative(self, args)
     830       
     831
     832    def _derivative(self, var=None):
     833        """
     834        The formal derivative of this Laurent series with respect to var.
     835       
     836        If var is None or the generator of this ring, it's the formal
     837        derivative as expected. Otherwise, _derivative(var) gets called
     838        recursively on each coefficient.
     839       
     840        .. seealso::
     841
     842           :meth:`derivative`
     843       
     844        EXAMPLES::
     845       
     846            sage: R.<x> = LaurentPolynomialRing(ZZ)
     847            sage: f = x^2 + 3*x^4
     848            sage: f._derivative()
     849            2*x + 12*x^3
     850            sage: f._derivative(x)
     851            2*x + 12*x^3
     852            sage: g = 1/x^10 - x + x^2 - x^4
     853            sage: g._derivative()
     854            -10*x^-11 - 1 + 2*x - 4*x^3
     855       
     856        Differentiating with respect to something other than the generator
     857        gets recursed into the base ring::
     858       
     859            sage: R.<t> = PolynomialRing(ZZ)
     860            sage: S.<x> = LaurentPolynomialRing(R)
     861            sage: f = 2*t/x + (3*t^2 + 6*t)*x
     862            sage: f._derivative(t)
     863            2*x^-1 + (6*t + 6)*x
     864        """
     865        if var is not None and var is not self._parent.gen():
     866            # call _derivative() recursively on coefficients
     867            u = [coeff._derivative(var) for coeff in self.__u.list()]
     868            u = self._parent.polynomial_ring()(u)
     869            return LaurentPolynomial_univariate(self._parent, u, self.__n)
     870
     871        # compute formal derivative with respect to generator
     872        if self.is_zero():
     873            return LaurentPolynomial_univariate(self._parent, 0)
     874        cdef long m, n = self.__n
     875        a = self.__u.list()
     876        v = [(n+m)*a[m] for m from 0 <= m < len(a)]
     877        u = self._parent.polynomial_ring()(v)
     878        return LaurentPolynomial_univariate(self._parent, u, n-1)
     879
     880       
     881    def integral(self):
     882        r"""
     883        The formal integral of this Laurent series with 0 constant term.
     884       
     885        EXAMPLES: The integral may or may not be defined if the base ring
     886        is not a field.
     887       
     888        ::
     889       
     890            sage: t = LaurentPolynomialRing(ZZ, 't').0
     891            sage: f = 2*t^-3 + 3*t^2
     892            sage: f.integral()
     893            -t^-2 + t^3
     894       
     895        ::
     896       
     897            sage: f = t^3
     898            sage: f.integral()
     899            Traceback (most recent call last):
     900            ...
     901            ArithmeticError: Coefficients of integral cannot be coerced into the base ring
     902       
     903        The integral of 1/t is `\log(t)`, which is not given by a
     904        Laurent polynomial::
     905       
     906            sage: t = LaurentPolynomialRing(ZZ,'t').0
     907            sage: f = -1/t^3 - 31/t
     908            sage: f.integral()
     909            Traceback (most recent call last):
     910            ...
     911            ArithmeticError: The integral of is not a Laurent polynomial, since t^-1 has nonzero coefficient.
     912       
     913        Another example with just one negative coefficient::
     914       
     915            sage: A.<t> = LaurentPolynomialRing(QQ)
     916            sage: f = -2*t^(-4)
     917            sage: f.integral()
     918            2/3*t^-3
     919            sage: f.integral().derivative() == f
     920            True
     921        """
     922        cdef long i, n = self.__n
     923        a = self.__u.list()
     924        if self[-1] != 0:
     925            raise ArithmeticError, \
     926                  "The integral of is not a Laurent polynomial, since t^-1 has nonzero coefficient."
     927
     928        if n < 0:
     929            v = [a[i]/(n+i+1) for i in range(min(-1-n,len(a)))] + [0]
     930        else:
     931            v = []
     932        v += [a[i]/(n+i+1) for i in range(max(-n,0), len(a))]
     933        try:
     934            u = self._parent.polynomial_ring()(v)
     935        except TypeError:
     936            raise ArithmeticError, "Coefficients of integral cannot be coerced into the base ring"
     937        return LaurentPolynomial_univariate(self._parent, u, n+1)
     938
     939
     940       
     941    def __call__(self, *x):
     942        """
     943        Compute value of this Laurent polynomial at x.
     944       
     945        EXAMPLES::
     946       
     947            sage: R.<t> = LaurentPolynomialRing(ZZ)
     948            sage: f = t^(-2) + t^2
     949            sage: f(2)
     950            17/4
     951            sage: f(-1)
     952            2
     953            sage: f(1/3)
     954            82/9
     955        """
     956        if isinstance(x[0], tuple):
     957            x = x[0]
     958        return self.__u(x) * (x[0]**self.__n)
     959
     960
     961def make_element_from_parent(parent, *args):
     962    return parent(*args)
    13963
    14964cdef class LaurentPolynomial_mpair(CommutativeAlgebraElement):
    15965    def __init__(self, parent, x, reduce=True):
     
    29979            sage: L(1/2)
    30980            1/2
    31981        """
    32         if isinstance(x, PolyDict):
     982        if isinstance(x, LaurentPolynomial_mpair):
     983            x = x.dict()
     984        elif isinstance(x, PolyDict):
    33985            x = x.dict()
    34986        if isinstance(x, dict):
    35987            self._mon = ETuple({},int(parent.ngens()))
     
    6841636                    term *= kwds[repr_g[i]]**mon[i]
    6851637                else:
    6861638                    term *= g[i]**mon[i]
     1639
    6871640            out += term
    6881641       
    6891642        return out
    6901643
     1644    def is_univariate(self):
     1645        """
     1646        Returns True if this is a univariate or constant Laurent polynomial,
     1647        and False otherwise.
     1648
     1649        EXAMPLES::
     1650
     1651            sage: R.<x,y,z> = LaurentPolynomialRing(QQ)
     1652            sage: f = (x^3 + y^-3)*z
     1653            sage: f.is_univariate()
     1654            False
     1655            sage: g = f(1,y,4)
     1656            sage: g.is_univariate()
     1657            True
     1658            sage: R(1).is_univariate()
     1659            True
     1660        """
     1661
     1662        return len(self.variables()) < 2
     1663
     1664    def univariate_polynomial(self, R=None):
     1665        """
     1666        Returns a univariate polynomial associated to this
     1667        multivariate polynomial.
     1668
     1669        INPUT:
     1670
     1671        - ``R`` - (default: ``None``) PolynomialRing
     1672
     1673        If this polynomial is not in at most one variable, then a
     1674        ``ValueError`` exception is raised.  The new polynomial is over
     1675        the same base ring as the given ``LaurentPolynomial`` and in the
     1676        variable ``x`` if no ring ``R`` is provided.
     1677
     1678        EXAMPLES::
     1679
     1680            sage: R.<x, y> = LaurentPolynomialRing(ZZ)
     1681            sage: f = 3*x^2 - 2*y^-1 + 7*x^2*y^2 + 5
     1682            sage: f.univariate_polynomial()
     1683            Traceback (most recent call last):
     1684            ...
     1685            TypeError: polynomial must involve at most one variable
     1686            sage: g = f(10,y); g
     1687            700*y^2 + 305 - 2*y^-1
     1688            sage: h = g.univariate_polynomial(); h
     1689            -2*y^-1 + 305 + 700*y^2
     1690            sage: h.parent()
     1691            Univariate Laurent Polynomial Ring in y over Rational Field
     1692            sage: g.univariate_polynomial(LaurentPolynomialRing(QQ,'z'))
     1693            -2*z^-1 + 305 + 700*z^2
     1694
     1695        Here's an example with a constant multivariate polynomial::
     1696
     1697            sage: g = R(1)
     1698            sage: h = g.univariate_polynomial(); h
     1699            1
     1700            sage: h.parent()
     1701            Univariate Laurent Polynomial Ring in x over Integer Ring
     1702        """
     1703        from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
     1704        v = self.variables()
     1705        if len(v) > 1:
     1706            raise TypeError, "polynomial must involve at most one variable"
     1707        elif len(v) == 1:
     1708            x = v[0]
     1709            i = self._parent.gens().index(x)
     1710        else:
     1711            x = 'x'
     1712            i = 0
     1713
     1714        #construct ring if none
     1715        if R is None:
     1716            R = LaurentPolynomialRing(self.base_ring(),x)
     1717
     1718        return R(dict((m[i],c) for m,c in self.dict().items()))       
    6911719
    6921720    def factor(self):
    6931721        """
  • sage/rings/polynomial/laurent_polynomial_ring.py

    diff -r 2a2abbcad325 sage/rings/polynomial/laurent_polynomial_ring.py
    a b  
    4747from sage.rings.polynomial.polynomial_ring_constructor import _single_variate as _single_variate_poly
    4848from sage.rings.polynomial.polynomial_ring_constructor import _multi_variate as _multi_variate_poly
    4949from sage.misc.latex import latex
    50 from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial_mpair
     50from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial_mpair, LaurentPolynomial_univariate
    5151from sage.rings.ring import CommutativeRing
    5252from sage.structure.parent_gens import ParentWithGens
    5353
     
    142142
    143143           sage: R.<w> = LaurentPolynomialRing(QQ)
    144144           sage: (1 + w)^3
    145            w^3 + 3*w^2 + 3*w + 1
     145           1 + 3*w + 3*w^2 + w^3
    146146       
    147147       You must specify a name::
    148148           
     
    328328        sage: _single_variate(QQ, ('x',), False)
    329329        Univariate Laurent Polynomial Ring in x over Rational Field
    330330    """
    331     ############################################################
    332     # This should later get moved to an actual single variate  #
    333     # implementation with valuation tracking,                  #
    334     # but I don't want to right now.                           #
    335     ############################################################
    336     # We need to come up with a name for the inverse that is easy to search
    337     # for in a string *and* doesn't overlap with the name that we already have.
    338     # For now, I'm going to use a name mangling with checking method.
    339331    names = normalize_names(1, names)
    340332    key = (base_ring, names, sparse)
    341333    P = _get_from_cache(key)
     
    347339            prepend_string += 'k'
    348340        else:
    349341            break
    350     R = _multi_variate_poly(base_ring, names, 1, sparse, 'degrevlex', None)
    351     P = LaurentPolynomialRing_mpair(R, prepend_string, names)
     342    R = _single_variate_poly(base_ring, names, sparse, None)
     343    P = LaurentPolynomialRing_univariate(R, names)
    352344    _save_in_cache(key, P)
    353345    return P
    354346
     
    458450        """
    459451        if i < 0 or i >= self._n:
    460452            raise ValueError, "generator not defined"
    461         return self(self._R.gen(i))
     453        try:
     454            return self.__generators[i]
     455        except AttributeError:
     456            self.__generators = tuple(self(x) for x in self._R.gens())
     457            return self.__generators[i]
     458
    462459
    463460    def is_integral_domain(self, proof = True):
    464461        """
     
    508505        else:
    509506            return LaurentPolynomialFunctor(vars[-1], True), LaurentPolynomialRing(self.base_ring(), vars[:-1])
    510507
     508
     509
    511510    def completion(self, p, prec=20, extras=None):
    512511        """
    513512        EXAMPLES::
    514513
    515             sage: LaurentPolynomialRing(QQ,2,'x').completion(3)
    516             Traceback (most recent call last):
    517             ...
    518             NotImplementedError
     514            sage: P.<x>=LaurentPolynomialRing(QQ)
     515            sage: P
     516            Univariate Laurent Polynomial Ring in x over Rational Field
     517            sage: PP=P.completion(x)
     518            sage: PP
     519            Laurent Series Ring in x over Rational Field
     520            sage: f=1-1/x
     521            sage: PP(f)
     522            -x^-1 + 1
     523            sage: 1/PP(f)
     524            -x - x^2 - x^3 - x^4 - x^5 - x^6 - x^7 - x^8 - x^9 - x^10 - x^11 - x^12 - x^13 - x^14 - x^15 - x^16 - x^17 - x^18 - x^19 - x^20 + O(x^21)
    519525        """
    520         raise NotImplementedError
     526        if str(p) == self._names[0] and self._n == 1:
     527            from sage.rings.laurent_series_ring import LaurentSeriesRing
     528            return LaurentSeriesRing(self.base_ring(), name=self._names[0])
     529        else:
     530            raise TypeError, "Cannot complete %s with respect to %s" % (self, p)
     531
     532
     533
    521534
    522535    def remove_var(self, var):
    523536        """
     
    555568            from sage.structure.coerce_maps import CallableConvertMap
    556569            return CallableConvertMap(R, self, self._element_constructor_,
    557570                                      parent_as_first_arg=False)
     571        elif isinstance(R, LaurentPolynomialRing_generic) and \
     572             R.variable_names() == self.variable_names() and \
     573             self.base_ring().has_coerce_map_from(R.base_ring()):
     574            return True
    558575        else:
    559576            f = self._R.coerce_map_from(R)
    560577            if f is not None:
     
    740757            base_ring = self.base_ring()
    741758        if names is None:
    742759            names = self.variable_names()
    743         if order is None:
    744             order = self.polynomial_ring().term_order()
    745760        if self._n == 1:
    746761            return LaurentPolynomialRing(base_ring, names[0], sparse = sparse)
    747762        else:
     763            if order is None:
     764                order = self.polynomial_ring().term_order()
    748765            return LaurentPolynomialRing(base_ring, self._n, names, order = order)
    749766
    750767
     768class LaurentPolynomialRing_univariate(LaurentPolynomialRing_generic):
     769    def __init__(self, R, names):
     770        """
     771        EXAMPLES::
     772
     773            sage: L = LaurentPolynomialRing(QQ,'x')
     774            sage: type(L)
     775            <class 'sage.rings.polynomial.laurent_polynomial_ring.LaurentPolynomialRing_univariate'>
     776            sage: L == loads(dumps(L))
     777            True
     778        """
     779        if R.ngens() != 1:
     780            raise ValueError, "n must be 1"
     781        if not R.base_ring().is_integral_domain():
     782            raise ValueError, "base ring must be an integral domain"
     783        LaurentPolynomialRing_generic.__init__(self, R, '', names)
     784
     785    def _element_constructor_(self, x):
     786        """
     787        EXAMPLES::
     788
     789            sage: L = LaurentPolynomialRing(QQ,2,'x')
     790            sage: L(1/2)
     791            1/2
     792        """
     793        return LaurentPolynomial_univariate(self, x)
     794
     795    def __reduce__(self):
     796        return LaurentPolynomialRing_univariate, (self._R, self._names)
     797
    751798class LaurentPolynomialRing_mpair(LaurentPolynomialRing_generic):
    752799    def __init__(self, R, prepend_string, names):
    753800        """
     
    775822        """
    776823        return LaurentPolynomial_mpair(self, x)
    777824   
     825    def __reduce__(self):
     826        return LaurentPolynomialRing_mpair, (self._R, self._prepend_string, self._names)
     827
     828