Ticket #9051: trac_9051-referee-1.patch

File trac_9051-referee-1.patch, 4.6 KB (added by was, 11 years ago)

apply this after the "everything flattened" patch directly above.

  • sage/rings/fraction_field_FpT.pyx

    # HG changeset patch
    # User William Stein <wstein@gmail.com>
    # Date 1279215262 25200
    # Node ID d1a9f796dd85691ee9a27e6bf992c1ebeea08f8c
    # Parent  144af5841476f7be4e46919f225d5ef4cac9a2d4
    9504 -- referee patch
    
    diff --git a/sage/rings/fraction_field_FpT.pyx b/sage/rings/fraction_field_FpT.pyx
    a b  
    6666   
    6767    def iter(self, bound=None, start=None):
    6868        """
     69        EXAMPLES::
     70       
    6971            sage: from sage.rings.fraction_field_FpT import *
    7072            sage: R.<t> = FpT(GF(5)['t'])
    7173            sage: list(R.iter(2))[350:355]
     
    353355
    354356    cdef int _cmp_c_impl(self, Element other) except -2:
    355357        """
    356         Compares this with another element.
     358        Compares this with another element.  The ordering is arbitrary,
     359        but it is an ordering, and it is consistent between runs.  It has
     360        nothing to do with the algebra structure.
    357361
    358362        TESTS::
    359363       
     
    373377            True
    374378            sage: 2*t/2 == t
    375379            True
     380
     381            sage: a = (t^3 + 3*t)/(5*t-2); b = (t^2-2)/(t-1)
     382            sage: b < a
     383            True
     384            sage: a < b
     385            False
     386            sage: 1/a < b
     387            True
     388            sage: b < 1/a
     389            False
    376390        """
    377391        # They are normalized.
    378         if (zmod_poly_equal(self._numer, (<FpTElement>other)._numer) and
    379             zmod_poly_equal(self._denom, (<FpTElement>other)._denom)):
    380             return 0
    381         else:
    382             return -1
     392        cdef int j = sage_cmp_zmod_poly_t(self._numer, (<FpTElement>other)._numer)
     393        if j: return j
     394        return sage_cmp_zmod_poly_t(self._denom, (<FpTElement>other)._denom)
    383395   
    384396    def __hash__(self):
    385397        """
     
    394406            sage: hash(K(5))
    395407            5
    396408            sage: set([1, t, 1/t, t, t, 1/t, 1+1/t, t/t])
    397             set([1, t, 1/t, (t + 1)/t])
     409            set([1, 1/t, t, (t + 1)/t])
     410            sage: a = (t+1)/(t^2-1); hash(a) == hash((a.numer(),a.denom()))
     411            True
    398412        """
    399413        if self.denom() == 1:
    400414            return hash(self.numer())
    401         return hash((self.numer(), self.numer()))
     415        return hash((self.numer(), self.denom()))
    402416       
    403417    def __neg__(self):
    404418        """
     
    633647                    zmod_poly_clear(g)
    634648        return next
    635649       
    636 #         if zmod_poly_degree(self._numer) == -1:
    637 #             zmod_poly_set_coeff_ui(x._numer, 0, 1)
    638 #             zmod_poly_set_coeff_ui(x._denom, 0, 1)
    639 #             return x
    640 #         elif zmod_poly_degree(self._numer) == 0:
    641 #             zmod_poly_set_coeff_ui(x._numer, 0, zmod_poly_get_coeff_ui(self._numer, 0) + 1)
    642 #             zmod_poly_set_coeff_ui(x._denom, 0, 1)
    643 #             if zmod_poly_get_coeff_ui(x._numer, 0) == 0:
    644 #                 zmod_poly_set_coeff_ui(x._numer, 1, 1)
    645 #             return x
    646 #         cdef zmod_poly_t g
    647 #         zmod_poly_init(g, self.p)
    648 #         zmod_poly_set(x._numer, self._numer)
    649 #         zmod_poly_set(x._denom, self._denom)
    650 #         while True:
    651 #             zmod_poly_inc(x._denom, True)
    652 #             if zmod_poly_degree(x._numer) < zmod_poly_degree(x._denom):
    653 #                 zmod_poly_inc(x._numer, False)
    654 #                 zmod_poly_zero(x._denom)
    655 #                 zmod_poly_set_coeff_ui(x._denom, 0, 1)
    656 #             zmod_poly_gcd(g, x._numer, x._denom)
    657 #             if zmod_poly_is_one(g):
    658 #                 zmod_poly_clear(g)
    659 #                 return x
    660    
    661650    cpdef _sqrt_or_None(self):
    662651        """
    663652        Returns the squre root of self, or None. Differs from sqrt() by not raising an exception.
     
    891880   
    892881    def __dealloc__(self):
    893882        """
    894         Deallocating of the self.g
     883        Deallocating of self.g.
    895884
    896885        TESTS::
    897886
     
    17721761        (t + 1)/t
    17731762    """
    17741763    return FpTElement(K, numer, denom, coerce=False, reduce=False)
     1764
     1765
     1766#  Somehow this isn't in FLINT, evidently.  It could be moved
     1767#  elsewhere at some point.
     1768cdef int sage_cmp_zmod_poly_t(zmod_poly_t L, zmod_poly_t R):
     1769    """
     1770    Compare two zmod_poly_t in a Pythonic way, so this returns -1, 0,
     1771    or 1, and is consistent.
     1772    """
     1773    cdef int j
     1774    cdef Py_ssize_t i
     1775
     1776    # First compare the degrees
     1777    j = zmod_poly_degree(L) - zmod_poly_degree(R)
     1778    if j<0: return -1
     1779    elif j>0: return 1
     1780   
     1781    # Same degree, so compare coefficients, term by term
     1782    for i in range(zmod_poly_degree(L)+1):
     1783        j = zmod_poly_get_coeff_ui(L,i) - zmod_poly_get_coeff_ui(R,i)
     1784        if j<0: return -1
     1785        elif j>0: return 1
     1786
     1787    # Two polynomials are equal
     1788    return 0