Ticket #10271: trac_10271.patch

File trac_10271.patch, 13.7 KB (added by boothby, 10 years ago)

apply only this patch

  • sage/rings/big_oh.py

    # HG changeset patch
    # Parent 5b2bc3154e8d467e993faa7638e8e9b94f1a8f96
    
    diff -r 5b2bc3154e8d sage/rings/big_oh.py
    a b  
    22Big O for various types (power series, p-adics, etc.)
    33"""
    44
    5 import sage.rings.arith as arith
    6 import laurent_series_ring_element
    7 import sage.rings.padics.factory as padics_factory
    8 import sage.rings.padics.padic_generic_element as padic_generic_element
    9 import power_series_ring_element
    10 import integer
    11 import rational
    12 from sage.rings.finite_rings.integer_mod import Mod
    13 from sage.rings.polynomial.polynomial_element import Polynomial
    14 
    155def O(x):
    166    """
    177    Big O constructor for various types.
     
    5747        11^-12 + O(11^15)
    5848       
    5949    """
    60     if isinstance(x, power_series_ring_element.PowerSeries):
    61         return x.parent()(0, x.degree())
    6250
    63     elif isinstance(x, Polynomial):
    64         if x.parent().ngens() != 1:
    65             raise NotImplementedError, "completion only currently defined for univariate polynomials"
    66         if not x.is_monomial():
    67             raise NotImplementedError, "completion only currently defined for the maximal ideal (x)"
    68         return x.parent().completion(x.parent().gen())(0, x.degree())
     51    import integer, rational
    6952
    70     elif isinstance(x, laurent_series_ring_element.LaurentSeries):
    71         return laurent_series_ring_element.LaurentSeries(x.parent(), 0).add_bigoh(x.valuation())
     53    try:
     54        if isinstance(x, (int, long, integer.Integer)):
     55            x=rational.Rational(x)
     56        return x.big_oh()
     57    except AttributeError:
     58        raise ArithmeticError, "Could not construct O(x)"
    7259
    73     elif isinstance(x, (int,long,integer.Integer,rational.Rational)):  # p-adic number
    74         if x <= 0:
    75             raise ArithmeticError, "x must be a prime power >= 2"
    76         F = arith.factor(x)
    77         if len(F) != 1:
    78             raise ArithmeticError, "x must be prime power"
    79         p, r = F[0]
    80         if r >= 0:
    81             return padics_factory.Zp(p, prec = max(r, 20), type = 'capped-rel')(0, absprec = r)
    82         else:
    83             return padics_factory.Qp(p, prec = max(r, 20), type = 'capped-rel')(0, absprec = r)
    84 
    85     elif isinstance(x, padic_generic_element.pAdicGenericElement):
    86          return x.parent()(0, absprec = x.valuation())
    87     raise ArithmeticError, "O(x) not defined"
    88 
     60#TODO Laurent Polynomial
  • sage/rings/integer.pyx

    diff -r 5b2bc3154e8d sage/rings/integer.pyx
    a b  
    54375437        else:
    54385438            raise ValueError("algorithm must be one of: 'pari', 'mpir'")
    54395439
     5440    def big_oh(self):
     5441        """
     5442        If self is a prime power, `self=p^e` return the `p`-adic number `O(p^e)`.
     5443        Otherwise, this makes no sense, so we raise an ArithmeticError. 
     5444
     5445        EXAMPLES::
     5446
     5447            sage: (7^6).big_oh()
     5448            O(7^6)
     5449            sage: 1/3 + O(7^6)
     5450            5 + 4*7 + 4*7^2 + 4*7^3 + 4*7^4 + 4*7^5 + O(7^6)
     5451       
     5452        """
     5453        import rational
     5454        return rational.Rational(self).big_oh()
     5455       
     5456       
    54405457
    54415458ONE = Integer(1)
    54425459Py_INCREF(ONE)
  • sage/rings/laurent_series_ring.py

    diff -r 5b2bc3154e8d sage/rings/laurent_series_ring.py
    a b  
    259259
    260260        - Any ring that canonically coerces to the base ring of R
    261261        """
     262        from sage.rings.polynomial.laurent_polynomial_ring import is_LaurentPolynomialRing
    262263        try:
    263264            P = x.parent()
    264             if is_LaurentSeriesRing(P):
     265            if is_LaurentSeriesRing(P) or is_LaurentPolynomialRing(P):
    265266                if P.variable_name() == self.variable_name():
    266267                    if self.has_coerce_map_from(P.base_ring()):
    267268                        return self(x)
  • sage/rings/laurent_series_ring_element.pyx

    diff -r 5b2bc3154e8d sage/rings/laurent_series_ring_element.pyx
    a b  
    11661166            x = x[0]
    11671167        return self.__u(x) * (x[0]**self.__n)
    11681168
     1169    def big_oh(self):
     1170        """
     1171        If this Laurent series is a monomial `x^n`, then return `O(x^n)`.
     1172        Otherwise, raise an ArithmeticError.
     1173       
     1174        EXAMPLES::
     1175       
     1176            sage: R.<t> = LaurentSeriesRing(ZZ)
     1177            sage: (278*t^4).big_oh()
     1178            O(t^4)
     1179            sage: (1+t).big_oh()
     1180            Traceback (most recent call last):
     1181            ...
     1182            ArithmeticError: O(x) not defined
     1183
     1184        """
     1185
     1186        if self.is_monomial():
     1187            return self.parent(0).add_bigoh(self.degree())
     1188        else:
     1189            raise ArithmeticError, "O(x) not defined"
     1190
     1191
    11691192
    11701193def make_element_from_parent(parent, *args):
    11711194    return parent(*args)
  • sage/rings/padics/padic_base_generic_element.pyx

    diff -r 5b2bc3154e8d sage/rings/padics/padic_base_generic_element.pyx
    a b  
    477477            mpz_mod(xnew, xnew, ppow)
    478478        mpz_clear(u)
    479479        mpz_clear(xnew)
     480
  • sage/rings/padics/padic_generic_element.pyx

    diff -r 5b2bc3154e8d sage/rings/padics/padic_generic_element.pyx
    a b  
    10471047            0.200000000000000
    10481048        """
    10491049        raise NotImplementedError
     1050
     1051
     1052    def big_oh(self):
     1053        """
     1054        Returns the `p`-adic `0 + O(x)` if `x = w^v` where `w` is the
     1055        generator of the `p`-adic ring self belongs to, and `v` is
     1056        the valuation of self.  Otherwise, raises an ArithmeticError.
     1057
     1058        EXAMPLES::
     1059
     1060            sage: K.<w> = Qp(5, 30)
     1061            sage: O(w^9)
     1062            O(w^9)
     1063            sage: S.<x> = ZZ[]
     1064            sage: E.<z> = K.ext(x^5 + 75*x^3 - 15*x^2 +125*x - 5)
     1065            sage: w + O(z^10)
     1066            z^5 + 2*z^7 + 4*z^9 + O(z^10)
     1067
     1068        TESTS::
     1069
     1070            sage: O(z+w)
     1071            Traceback (most recent call last):
     1072            ...
     1073            ArithmeticError: Cannot construct O(x)
     1074
     1075        """
     1076
     1077        t = self.parent().gen()**self.valuation()
     1078        if self == t:
     1079            return self.parent()(0, absprec = self.valuation())
     1080        raise ArithmeticError, "Cannot construct O(x)"
  • sage/rings/polynomial/laurent_polynomial.pyx

    diff -r 5b2bc3154e8d sage/rings/polynomial/laurent_polynomial.pyx
    a b  
    500500        # 3. Subtract
    501501        return LaurentPolynomial_univariate(self._parent, f1 - f2, m)
    502502
     503    def add_bigoh(self, prec):
     504        """
     505        EXAMPLES::
     506       
     507            sage: R.<t> = LaurentPolynomialRing(QQ)
     508            sage: f = t^2 + t^3 + O(t^10); f
     509            t^2 + t^3 + O(t^10)
     510            sage: f.add_bigoh(5)
     511            t^2 + t^3 + O(t^5)
     512        """
     513        from sage.rings.infinity import infinity
     514        if prec == infinity:
     515            return self
     516        r = self._parent.completion(self._parent.gen())
     517        return r(self.truncate(prec)).add_bigoh(prec)
    503518
    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)
     519    def big_oh(self):
     520        """
     521        Returns O(self) if self is a monomial, and otherwise raises an ArithmeticError.
    518522
     523        EXAMPLES::
     524       
     525            sage: k.<w> = LaurentPolynomialRing(QQ,'w')
     526            sage: (19*w^-17).big_oh()
     527            O(w^-17)
     528            sage: (w^12 + 17).big_oh()
     529            Traceback (most recent call last):
     530            ...
     531            ArithmeticError: O(x) not defined
     532            sage: k(0).big_oh()
     533            Traceback (most recent call last):
     534            ...
     535            ArithmeticError: O(x) not defined
     536
     537        """
     538        if self.is_monomial() and self:
     539            r = self._parent.completion(self._parent.gen())
     540            return r(0).add_bigoh(self.degree())
     541        raise ArithmeticError, "O(x) not defined"
     542       
    519543    def degree(self):
    520544        """
    521545        Return the degree of this polynomial.
     
    17841808                f.append( (self.parent(d),t[1]) )
    17851809
    17861810        return Factorization(f, unit=u)
     1811
  • sage/rings/polynomial/laurent_polynomial_ring.py

    diff -r 5b2bc3154e8d sage/rings/polynomial/laurent_polynomial_ring.py
    a b  
    563563                      From: Multivariate Polynomial Ring in x, y over Rational Field
    564564                      To:   Multivariate Laurent Polynomial Ring in x, y over Rational Field
    565565        """
    566        
     566        from sage.rings.laurent_series_ring import is_LaurentSeriesRing
    567567        if R is self._R:
    568568            from sage.structure.coerce_maps import CallableConvertMap
    569569            return CallableConvertMap(R, self, self._element_constructor_,
    570570                                      parent_as_first_arg=False)
    571         elif isinstance(R, LaurentPolynomialRing_generic) and \
     571        elif is_LaurentPolynomialRing(R) and \
    572572             R.variable_names() == self.variable_names() and \
    573573             self.base_ring().has_coerce_map_from(R.base_ring()):
    574574            return True
     575        elif is_LaurentSeriesRing(R):
     576            return False
    575577        else:
    576578            f = self._R.coerce_map_from(R)
    577579            if f is not None:
  • sage/rings/polynomial/polynomial_element.pyx

    diff -r 5b2bc3154e8d sage/rings/polynomial/polynomial_element.pyx
    a b  
    55205520                w += 1
    55215521        return w
    55225522
     5523    def big_oh(self):
     5524        """
     5525        Returns O(self) if self is a monomial.
     5526
     5527        EXAMPLES::
     5528       
     5529            sage: k.<w> = QQ[]
     5530            sage: w.big_oh()
     5531            O(w^1)
     5532            sage: (w^9).big_oh()
     5533            O(w^9)
     5534
     5535        TESTS::
     5536
     5537            sage: (1 + w).big_oh()
     5538            Traceback (most recent call last):
     5539            ...
     5540            ArithmeticError: O(x) not defined
     5541            sage: k(0).big_oh()
     5542            Traceback (most recent call last):
     5543            ...
     5544            ArithmeticError: O(x) not defined
     5545
     5546        """
     5547
     5548        if self.is_monomial():
     5549            return self.parent().completion(self.parent().gen())(0, self.degree())
     5550        raise ArithmeticError, "O(x) not defined"
     5551       
     5552
    55235553# ----------------- inner functions -------------
    55245554# Cython can't handle function definitions inside other function
    55255555   
  • sage/rings/power_series_ring_element.pyx

    diff -r 5b2bc3154e8d sage/rings/power_series_ring_element.pyx
    a b  
    13521352        coeffs = self[:prec]
    13531353        return self._parent(coeffs, prec)
    13541354
     1355    def big_oh(self):
     1356        """
     1357        Returns O(self) if self is a monomial.
     1358
     1359        EXAMPLES::
     1360       
     1361            sage: k.<w> = QQ[[]]
     1362            sage: w.big_oh()
     1363            O(w^1)
     1364            sage: (w^9).big_oh()
     1365            O(w^9)
     1366
     1367        TESTS::
     1368
     1369            sage: (1 + w).big_oh()
     1370            Traceback (most recent call last):
     1371            ...
     1372            ArithmeticError: O(x) not defined
     1373            sage: k(0).big_oh()
     1374            Traceback (most recent call last):
     1375            ...
     1376            ArithmeticError: O(x) not defined
     1377
     1378        """
     1379
     1380        if self.is_monomial():
     1381            return self.parent()(0,self.degree())
     1382        else:
     1383            raise ArithmeticError, "O(x) not defined"
     1384
    13551385
    13561386    def solve_linear_de(self, prec = infinity, b = None, f0 = None):
    13571387        r"""
     
    17751805        s += pari('O(%s^%d)' % (s.variable(), n))  # PARI series
    17761806        return s
    17771807
     1808
    17781809def _solve_linear_de(R, N, L, a, b, f0):
    17791810    r"""
    17801811    Internal function used by PowerSeries.solve_linear_de().
  • sage/rings/rational.pyx

    diff -r 5b2bc3154e8d sage/rings/rational.pyx
    a b  
    33753375        if neg: v = -v
    33763376        return v
    33773377
     3378    def big_oh(self):
     3379        """
     3380        If self is a prime power, `self=p^e` return the `p`-adic number `O(p^e)`.
     3381        Otherwise, this makes no sense, so we raise an ArithmeticError. 
     3382
     3383        EXAMPLES::
     3384
     3385            sage: (7^-6).big_oh()
     3386            O(7^-6)
     3387            sage: 1/3 + O(7^6)
     3388            5 + 4*7 + 4*7^2 + 4*7^3 + 4*7^4 + 4*7^5 + O(7^6)
     3389       
     3390        """
     3391        import sage.rings.padics.factory as padics_factory
     3392        from sage.rings.arith import is_prime_power
     3393
     3394        if self <= 0 or self == 1 or not is_prime_power(self):
     3395            raise ArithmeticError, "x must be a prime power >= 2"
     3396
     3397        F = self.factor()
     3398        if len(F) != 1:
     3399            raise ArithmeticError, "x must be prime power"
     3400        p, r = F[0]
     3401        if r >= 0:
     3402            return padics_factory.Zp(p, prec = max(r, 20), type = 'capped-rel')(0, absprec = r)
     3403        else:
     3404            return padics_factory.Qp(p, prec = max(r, 20), type = 'capped-rel')(0, absprec = r)
     3405
    33783406def pyrex_rational_reconstruction(integer.Integer a, integer.Integer m):
    33793407    """
    33803408    Find the rational reconstruction of a mod m, if it exists.