Merge branch 'public/4618' of git://trac.sagemath.org/sage into puiseux_series_4618

Author: soehms

src/doc/en/reference/power_series/index.rst

@@ -19,6 +19,9 @@ Power Series Rings and Laurent Series Rings
    sage/rings/lazy_laurent_series_ring
    sage/rings/lazy_laurent_series_operator
 
+   sage/rings/puiseux_series_ring
+   sage/rings/puiseux_series_ring_element
+
    sage/rings/tate_algebra
 
 .. include:: ../footer.txt

src/module_list.py

@@ -1192,6 +1192,9 @@ def uname_specific(name, value, alternative):
     Extension('sage.rings.tate_algebra_ideal',
               sources = ['sage/rings/tate_algebra_ideal.pyx']),
 
+    Extension('sage.rings.puiseux_series_ring_element',
+              sources = ['sage/rings/puiseux_series_ring_element.pyx']),
+
     Extension('sage.rings.rational',
               sources = ['sage/rings/rational.pyx'],
               libraries=['ntl']),

src/sage/rings/all.py

@@ -133,6 +133,10 @@
 # Tate algebras
 from .tate_algebra import TateAlgebra
 
+# Puiseux series ring
+from .puiseux_series_ring import PuiseuxSeriesRing
+from .puiseux_series_ring_element import PuiseuxSeries
+
 # Pseudo-ring of PARI objects.
 from .pari_ring import PariRing, Pari
 

src/sage/rings/big_oh.py

@@ -13,6 +13,7 @@
 
 import sage.arith.all as arith
 from . import laurent_series_ring_element
+from sage.rings.puiseux_series_ring_element import PuiseuxSeries
 import sage.rings.padics.factory as padics_factory
 import sage.rings.padics.padic_generic_element as padic_generic_element
 from . import power_series_ring_element
@@ -87,6 +88,15 @@ def O(*x, **kwds):
         sage: O(n)
         O(n)
 
+    Application with Puiseux series::
+
+        sage: P.<y> = PuiseuxSeriesRing(ZZ)
+        sage: y^(1/5) + O(y^(1/3))
+        y^(1/5) + O(y^(1/3))
+        sage: y^(1/3) + O(y^(1/5))
+        O(y^(1/5))
+
+
     TESTS::
 
         sage: var('x, y')
@@ -133,6 +143,9 @@ def O(*x, **kwds):
         return laurent_series_ring_element.LaurentSeries(x.parent(), 0).\
             add_bigoh(x.valuation(), **kwds)
 
+    elif isinstance(x, PuiseuxSeries):
+        return x.add_bigoh(x.valuation(), **kwds)
+
     elif isinstance(x, integer_types + (integer.Integer, rational.Rational)):
         # p-adic number
         if x <= 0:

src/sage/rings/laurent_series_ring_element.pyx

@@ -363,6 +363,66 @@ cdef class LaurentSeries(AlgebraElement):
             s += " + %s"%bigoh
         return s[1:]
 
+    def verschiebung(self, n):
+        r"""
+        Return the ``n``-th Verschiebung of ``self``.
+
+        If `f = \sum a_m x^m` then this function returns `\sum a_m x^{mn}`.
+
+        EXAMPLES::
+
+            sage: R.<x> = LaurentSeriesRing(QQ)
+            sage: f = -1/x + 1 + 2*x^2 + 5*x^5
+            sage: f.V(2)
+            -x^-2 + 1 + 2*x^4 + 5*x^10
+            sage: f.V(-1)
+            5*x^-5 + 2*x^-2 + 1 - x
+            sage: h = f.add_bigoh(7)
+            sage: h.V(2)
+            -x^-2 + 1 + 2*x^4 + 5*x^10 + O(x^14)
+            sage: h.V(-2)
+            Traceback (most recent call last):
+            ...
+            ValueError: For finite precision only positive arguments allowed
+
+        TESTS::
+
+            sage: R.<x> = LaurentSeriesRing(QQ)
+            sage: f = x
+            sage: f.V(3)
+            x^3
+            sage: f.V(-3)
+            x^-3
+            sage: g = 2*x^(-1) + 3 + 5*x
+            sage: g.V(-1)
+            5*x^-1 + 3 + 2*x
+        """
+        if n == 0:
+            raise ValueError('n must be non zero')
+
+        if n < 0:
+            if not self.prec() is infinity:
+                raise ValueError('For finite precision only positive arguments allowed')
+
+            exponents = [e * n for e in self.exponents()]
+            u = min(exponents)
+            exponents = [e - u for e in exponents]
+            coefficients = self.coefficients()
+            zero = self.base_ring().zero()
+            w = [zero] * (max(exponents) + 1)
+            for i in range(len(exponents)):
+                e = exponents[i]
+                c = coefficients[i]
+                w[e] = c
+            l = LaurentSeries(self._parent, w, u)
+        else:
+            __u = self.__u.V(n)
+            __n = <long>self.__n * n
+            l = LaurentSeries(self._parent, __u, __n)
+        return l
+
+    V = verschiebung
+
     def _latex_(self):
         r"""
         EXAMPLES::
@@ -1307,7 +1367,7 @@ cdef class LaurentSeries(AlgebraElement):
             return self.prec() - self.valuation()
 
     def __copy__(self):
-        return type(self)(self._parent, self.__u.copy(), self.__n)
+        return type(self)(self._parent, self.__u.__copy__(), self.__n)
 
     def reverse(self, precision=None):
         """