passagemath-flint 10.5.43__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.1rc1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/rings/fraction_field_FpT.pyx

@@ -573,6 +573,35 @@ cdef class FpTElement(FieldElement):
         normalize(x._numer, x._denom, self.p)
         return x
 
+    def _im_gens_(self, codomain, im_gens, base_map=None):
+        r"""
+        Return the image of this element in ``codomain`` under the
+        map that sends the image of the generator of the parent to
+        the element in ``im_gens``.
+
+        INPUT:
+
+        - ``codomain`` -- a ring; where the image is computed
+
+        - ``im_gens`` -- a list containing the image of the
+          generator of the parent as unique element
+
+        - ``base_map`` -- a morphism (default: ``None``);
+          the action on the underlying base ring
+
+        EXAMPLES::
+
+            sage: A.<T> = GF(5)[]
+            sage: K.<T> = Frac(A)
+            sage: f = K.hom([T^2])
+            sage: f(1/T)
+            1/T^2
+        """
+        nden = self.denom()._im_gens_(codomain, im_gens, base_map=base_map)
+        invden = nden.inverse_of_unit()
+        nnum = self.numer()._im_gens_(codomain, im_gens, base_map=base_map)
+        return nnum * invden
+
     cpdef FpTElement next(self):
         """
         Iterate through all polynomials, returning the "next" polynomial after this one.

sage/rings/number_field/S_unit_solver.py

@@ -1420,7 +1420,7 @@ def defining_polynomial_for_Kp(prime, prec=106):
         L = [g.change_ring(ZZ) for g, _ in factors]
         A = [g for g in L if (g(theta)).valuation(prime) >= e*N/2]
 
-        # We narrow down the list unitl only one value remains
+        # We narrow down the list until only one value remains
 
         if len(A) == 1:
             return A[0].change_ring(Integers(p**prec)).change_ring(ZZ)

sage/rings/number_field/galois_group.py

@@ -995,7 +995,7 @@ class GaloisGroup_v2(GaloisGroup_perm):
             sage: x = polygen(ZZ, 'x')
             sage: K.<b> = NumberField(x^4 - 2*x^2 + 2, 'a').galois_closure()
             sage: G = K.galois_group()
-            sage: sorted([G.artin_symbol(P) for P in K.primes_above(7)])
+            sage: sorted([G.artin_symbol(P) for P in K.primes_above(7)])  # random (see remark in primes_above)
             [(1,4)(2,3)(5,8)(6,7),
              (1,4)(2,3)(5,8)(6,7),
              (1,5)(2,6)(3,7)(4,8),

sage/rings/number_field/morphism.py

@@ -7,18 +7,17 @@ This module provides classes to represent ring homomorphisms between number
 fields (i.e. field embeddings).
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 William Stein <wstein@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.misc.cachefunc import cached_method
-from sage.misc.lazy_import import lazy_import
 
 from sage.rings.morphism import RingHomomorphism_im_gens, RingHomomorphism
 from sage.structure.sequence import Sequence

sage/rings/number_field/number_field.py

@@ -86,8 +86,6 @@ import sage.rings.abc
 import sage.rings.complex_mpfr
 from sage.rings.polynomial.polynomial_element import Polynomial
 import sage.rings.real_mpfr
-import sage.rings.real_mpfi
-import sage.rings.complex_double
 import sage.rings.real_double
 import sage.rings.real_lazy
 
@@ -114,6 +112,7 @@ from sage.structure.proof.proof import get_flag
 from . import maps
 from . import structure
 from . import number_field_morphisms
+from . import number_field_base
 
 from sage.categories.homset import Hom
 from sage.categories.sets_cat import Sets
@@ -124,6 +123,33 @@ from sage.rings.real_mpfr import RR
 from sage.interfaces.abc import GapElement
 from sage.rings.number_field.morphism import RelativeNumberFieldHomomorphism_from_abs
 
+from sage.misc.latex import latex
+
+import sage.rings.infinity as infinity
+from sage.rings.rational import Rational
+from sage.rings.integer import Integer
+import sage.rings.polynomial.polynomial_element as polynomial_element
+import sage.groups.abelian_gps.abelian_group
+import sage.rings.complex_interval_field
+
+from sage.structure.factory import UniqueFactory
+from . import number_field_element
+from . import number_field_element_quadratic
+from .number_field_ideal import NumberFieldIdeal, NumberFieldFractionalIdeal
+
+try:
+    from sage.libs.pari import pari
+    from cypari2.gen import Gen as pari_gen
+except ImportError:
+    pari_gen = ()
+
+from sage.rings.rational_field import QQ
+from sage.rings.integer_ring import ZZ
+from sage.rings.cif import CIF
+from sage.rings.real_double import RDF
+from sage.rings.real_lazy import RLF, CLF
+from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
+
 lazy_import('sage.libs.gap.element', 'GapElement', as_='LibGapElement')
 lazy_import('sage.misc.sage_eval', 'sage_eval')
 lazy_import('sage.rings.number_field.unit_group', 'UnitGroup')
@@ -134,18 +160,14 @@ lazy_import('sage.rings.universal_cyclotomic_field', 'UniversalCyclotomicFieldEl
 _NumberFields = NumberFields()
 
 
-def is_NumberFieldHomsetCodomain(codomain):
+def is_NumberFieldHomsetCodomain(codomain, category=None):
     """
-    Return whether ``codomain`` is a valid codomain for a number
-    field homset.
-
-    This is used by NumberField._Hom_ to determine
-    whether the created homsets should be a
-    :class:`sage.rings.number_field.homset.NumberFieldHomset`.
+    Return whether ``codomain`` is a valid codomain for a
+    :class:`NumberFieldHomset` in ``category``.
 
     EXAMPLES:
 
-    This currently accepts any parent (CC, RR, ...) in :class:`Fields`::
+    This currently accepts any ring (CC, RR, ...)::
 
         sage: from sage.rings.number_field.number_field import is_NumberFieldHomsetCodomain
         sage: is_NumberFieldHomsetCodomain(QQ)
@@ -154,24 +176,31 @@ def is_NumberFieldHomsetCodomain(codomain):
         sage: is_NumberFieldHomsetCodomain(NumberField(x^2 + 1, 'x'))
         True
         sage: is_NumberFieldHomsetCodomain(ZZ)
-        False
+        True
         sage: is_NumberFieldHomsetCodomain(3)
         False
         sage: is_NumberFieldHomsetCodomain(MatrixSpace(QQ, 2))
-        False
+        True
         sage: is_NumberFieldHomsetCodomain(InfinityRing)
-        False
-
-    Question: should, for example, QQ-algebras be accepted as well?
+        True
 
-    Caveat: Gap objects are not (yet) in :class:`Fields`, and therefore
-    not accepted as number field homset codomains::
+    Gap objects are not (yet) in :class:`Fields`, and therefore not accepted as
+    number field homset codomains::
 
         sage: is_NumberFieldHomsetCodomain(gap.Rationals)                               # needs sage.libs.gap
         False
     """
-    from sage.categories.fields import Fields
-    return codomain in Fields()
+    from sage.categories.rings import Rings
+
+    if category is None:
+        category = codomain.category()
+
+    if not category.is_subcategory(Rings()):
+        return False
+
+    assert codomain in category
+
+    return True
 
 
 def proof_flag(t):
@@ -196,36 +225,6 @@ def proof_flag(t):
     return get_flag(t, "number_field")
 
 
-from sage.misc.latex import latex
-
-import sage.rings.infinity as infinity
-from sage.rings.rational import Rational
-from sage.rings.integer import Integer
-import sage.rings.polynomial.polynomial_element as polynomial_element
-import sage.groups.abelian_gps.abelian_group
-import sage.rings.complex_interval_field
-
-from sage.structure.factory import UniqueFactory
-from . import number_field_element
-from . import number_field_element_quadratic
-from .number_field_ideal import NumberFieldIdeal, NumberFieldFractionalIdeal
-
-from sage.rings.rational_field import QQ
-from sage.rings.integer_ring import ZZ
-from sage.rings.real_mpfi import RIF
-from sage.rings.cif import CIF
-from sage.rings.real_double import RDF
-from sage.rings.complex_double import CDF
-from sage.rings.real_lazy import RLF, CLF
-from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
-
-try:
-    from sage.libs.pari import pari
-    from cypari2.gen import Gen as pari_gen
-except ImportError:
-    pari_gen = ()
-
-
 def NumberField(polynomial, name=None, check=True, names=None, embedding=None,
                 latex_name=None, assume_disc_small=False, maximize_at_primes=None, structure=None,
                 *, latex_names=None, **kwds):
@@ -1200,9 +1199,6 @@ class CyclotomicFieldFactory(UniqueFactory):
 CyclotomicField = CyclotomicFieldFactory("sage.rings.number_field.number_field.CyclotomicField")
 
 
-from . import number_field_base
-
-
 is_NumberField = number_field_base.is_NumberField
 
 
@@ -1990,10 +1986,9 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             sage: loads(dumps(H)) is H
             True
         """
-        if not is_NumberFieldHomsetCodomain(codomain):
-            # Using LazyFormat fixes #28036 - infinite loop
-            from sage.misc.lazy_format import LazyFormat
-            raise TypeError(LazyFormat("%s is not suitable as codomain for homomorphisms from %s") % (codomain, self))
+        if not is_NumberFieldHomsetCodomain(codomain, category):
+            raise TypeError
+
         from sage.rings.number_field.homset import NumberFieldHomset
         return NumberFieldHomset(self, codomain, category)
 
@@ -2053,6 +2048,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
         if p == infinity.infinity:
             gen_image = self.gen_embedding()
             if gen_image is not None:
+                from sage.rings.complex_double import CDF
+
                 if gen_image in RDF:
                     return QQ.completion(p, prec, extras)
                 elif gen_image in CDF:
@@ -2609,11 +2606,11 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
         f = x**2 + x
         while w < u and not w % 2:
             s = F.lift(q((a - 1) / pi**w).sqrt())
-            a = a / (1 + s*(pi**(w/2)))**2
+            a = a / (1 + s * (pi**(w / 2)))**2
             w = (a - 1).valuation(p)
         if w < u and w % 2:
             return v + w
-        if w == u and (f + F((a-1) / 4)).is_irreducible():
+        if w == u and (f + F((a - 1) / 4)).is_irreducible():
             return v + w
         return Infinity
 
@@ -3424,7 +3421,7 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
                     H.append(chi)
         return H
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return string representation of this number field.
 
@@ -3444,7 +3441,7 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             result += " with {} = {}".format(self.variable_name(), gen)
         return result
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return latex representation of this number field. This is viewed as
         a polynomial quotient ring over a field.
@@ -3934,6 +3931,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
              Fractional ideal (3)]
             sage: K.primes_of_bounded_norm(1)
             []
+            sage: K.primes_of_bounded_norm(1.1)
+            []
             sage: x = polygen(QQ, 'x')
             sage: K.<a> = NumberField(x^3 - 2)
             sage: P = K.primes_of_bounded_norm(30)
@@ -3953,7 +3952,7 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             B = ZZ(B)
         except (TypeError, AttributeError):
             try:
-                B = ZZ(B.ceil())
+                B = ZZ(B.floor())
             except (TypeError, AttributeError):
                 raise TypeError("%s is not valid bound on prime ideals" % B)
         if B < 2:
@@ -4616,6 +4615,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             ``proof.number_field(False)``. It can easily take 1000s of times
             longer to do computations with ``proof=True`` (the default).
         """
+        from .class_group import ClassGroup
+
         proof = proof_flag(proof)
         try:
             return self.__class_group[proof, names]
@@ -4703,6 +4704,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             Class group of order 4 with structure C4 of Number Field in a
              with defining polynomial x^2 + 14 with a = 3.741657386773942?*I
         """
+        from .class_group import SClassGroup
+
         proof = proof_flag(proof)
         if all(P.is_principal() for P in S):
             C = self.class_group(proof=proof)
@@ -6531,10 +6534,10 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
         # faster than computing all the conjugates, etc ...
 
         # flag to disable FLATTER, which is much more unstable than fplll
-        flag = 1 if pari.version() >= (2,17) else 0
+        flag = 1 if pari.version() >= (2, 17) else 0
         if self.is_totally_real():
             from sage.matrix.constructor import matrix
-            M = matrix(ZZ, d, d, [[(x*y).trace() for x in ZK] for y in ZK])
+            M = matrix(ZZ, d, d, [[(x * y).trace() for x in ZK] for y in ZK])
             T = pari(M).qflllgram(flag=flag)
         else:
             M = self.minkowski_embedding(ZK, prec=prec)
@@ -6709,10 +6712,12 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             sage: QuadraticField(3, 'a').narrow_class_group()
             Multiplicative Abelian group isomorphic to C2
         """
+        from sage.groups.abelian_gps.abelian_group import AbelianGroup
+
         proof = proof_flag(proof)
         k = self.pari_bnf(proof)
         s = k.bnfnarrow().sage()
-        return sage.groups.abelian_gps.abelian_group.AbelianGroup(s[1])
+        return AbelianGroup(s[1])
 
     def ngens(self):
         """
@@ -6778,6 +6783,7 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             return (self.__polynomial_ntl, self.__denominator_ntl)
         except AttributeError:
             import sage.libs.ntl.all as ntl
+
             self.__denominator_ntl = ntl.ZZ()
             den = self.polynomial().denominator()
             self.__denominator_ntl.set_from_sage_int(ZZ(den))
@@ -7223,6 +7229,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
              -a^15 - a^14 - 2*a^11 - a^10 + a^9 - a^8 - 2*a^7 + a^5 - 2*a^3 + a^2 + 3*a - 1,
              -3*a^16 - 3*a^15 - 3*a^14 - 3*a^13 - 3*a^12 - 2*a^11 - 2*a^10 - 2*a^9 - a^8 + a^7 + 2*a^6 + 3*a^5 + 3*a^4 + 4*a^3 + 6*a^2 + 8*a + 8]
         """
+        from sage.rings.number_field.unit_group import UnitGroup
+
         proof = proof_flag(proof)
 
         try:
@@ -7339,6 +7347,8 @@ class NumberField_generic(WithEqualityById, number_field_base.NumberField):
             sage: U.log(u)
             (1, 1, 4, 1, 5)
         """
+        from sage.rings.number_field.unit_group import UnitGroup
+
         proof = proof_flag(proof)
 
         # process the parameter S:
@@ -9651,6 +9661,8 @@ class NumberField_absolute(NumberField_generic):
                Defn: alpha |--> 0.96 + 1.7*I]
         """
         if prec is None:
+            from sage.rings.real_mpfi import RIF
+
             R = RIF
             C = CIF
 
@@ -10476,7 +10488,7 @@ class NumberField_absolute(NumberField_generic):
         # symbol is negative for all primes in S and positive
         # at all primes in S'
         # For technical reasons, a Hilbert symbol of -1 is
-        # respresented as 1 and a Hilbert symbol of 1
+        # represented as 1 and a Hilbert symbol of 1
         # is represented as 0
         V = VectorSpace(GF(2), len(SL))
         v = V([1]*len(S) + [0]*len(L))
@@ -10871,8 +10883,9 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
             # As a consequence, a result of _an_element_() with the wrong class
             # is cached during the call to has_coerce_map_from. We reset the
             # cache afterwards.
+            from sage.rings.complex_double import CDF
+
             self._standard_embedding = not CDF.has_coerce_map_from(self) or CDF(self.gen()).imag() > 0
-            self._cache_an_element = None
 
             if n == 4:
                 self._element_class = number_field_element_quadratic.NumberFieldElement_gaussian
@@ -11028,7 +11041,7 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
         from sage.libs.gap.libgap import libgap
         return libgap.CyclotomicField(self.__n)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return string representation of this cyclotomic field.
 
@@ -11060,7 +11073,7 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
         """
         return self.__n
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return the latex representation of this cyclotomic field.
 
@@ -11301,6 +11314,8 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
             sage: K5._log_gen(zeta15**3)
             4
         """
+        from sage.rings.complex_double import CDF
+
         X = x.parent()
         gen = self.gen()
 
@@ -11502,13 +11517,11 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
         zeta = self.gen()
         return sum(QQ(c) * zeta**i for i, c in enumerate(coeffs))
 
-    def _Hom_(self, codomain, cat=None):
+    def _Hom_(self, codomain, category=None):
         """
         Return homset of homomorphisms from the cyclotomic field ``self`` to
         the number field codomain.
 
-        The ``cat`` option is currently ignored.
-
         EXAMPLES:
 
         This function is implicitly called by the Hom method or
@@ -11525,13 +11538,20 @@ class NumberField_cyclotomic(NumberField_absolute, sage.rings.abc.NumberField_cy
                to Number Field in a with defining polynomial x^2 + 3
             sage: End(CyclotomicField(21))
             Automorphism group of Cyclotomic Field of order 21 and degree 12
+
+        ::
+
+            sage: K = CyclotomicField(3)
+            sage: Hom(K, ZZ).category()
+            Category of homsets of euclidean domains and noetherian rings
+
         """
-        if is_NumberFieldHomsetCodomain(codomain):
-            from sage.rings.number_field.homset import CyclotomicFieldHomset
-            return CyclotomicFieldHomset(self, codomain)
-        else:
+        if not is_NumberFieldHomsetCodomain(codomain, category):
             raise TypeError
 
+        from sage.rings.number_field.homset import CyclotomicFieldHomset
+        return CyclotomicFieldHomset(self, codomain, category)
+
     def is_galois(self):
         """
         Return ``True`` since all cyclotomic fields are automatically Galois.
@@ -12101,6 +12121,8 @@ class NumberField_quadratic(NumberField_absolute, sage.rings.abc.NumberField_qua
 
         self._NumberField_generic__gen = self._element_class(self, parts)
 
+        from sage.rings.complex_double import CDF
+
         # we must set the flag _standard_embedding *before* any element creation
         # Note that in the following code, no element is built.
         if self.coerce_embedding() is not None and CDF.has_coerce_map_from(self):

sage/rings/number_field/number_field_element.pyx

@@ -889,6 +889,43 @@ cdef class NumberFieldElement(NumberFieldElement_base):
 
         EXAMPLES::
 
+            sage: x = polygen(ZZ, 'x')
+            sage: K.<a> = NumberField(x^3 - 2)
+            sage: a._random_element()  # random
+            -1/2*a^2 - 4
+            sage: K.<a> = NumberField(x^2 - 5)
+            sage: a._random_element()  # random
+            -1/48*a - 1/2
+
+        With denominator bound one, we always get integral elements::
+
+            sage: K = QuadraticField(2)
+            sage: uu = [K.random_element(den_bound=1) for _ in range(5)]
+            sage: uu  # random
+            [0, a + 2, -12*a - 2, -a + 1, -a - 2]
+            sage: all(u.is_integral() for u in uu)
+            True
+
+        Without this constraint, we do not always get them::
+
+            sage: K = QuadraticField(2)
+            sage: uu = [K.random_element() for _ in range(100)]
+            sage: all(u.is_integral() for u in uu)
+            False
+
+        Random integral elements can also be picked using the random_element
+        method of the number field's "ring of integers" or "maximal order" ::
+
+            sage: K = QuadraticField(2)
+            sage: O = K.maximal_order()
+            sage: O.random_element()  # random
+            5*a - 6
+            sage: O = K.ring_of_integers()
+            sage: O.random_element()  # random
+            -4*a + 1
+
+        TESTS::
+
             sage: x = polygen(ZZ, 'x')
             sage: K.<a> = NumberField(x^3 - 2)
             sage: a._random_element().parent() is K
@@ -5311,6 +5348,23 @@ cdef class OrderElement_absolute(NumberFieldElement_absolute):
         """
         return self._parent.number_field()(NumberFieldElement_absolute.__invert__(self))
 
+    def canonical_associate(self):
+        """
+        Return a canonical associate.
+
+        Only implemented here because order elements inherit from field elements,
+        but the canonical associate implemented there does not apply here.
+
+        EXAMPLES::
+
+            sage: x = polygen(ZZ, 'x')
+            sage: K = NumberField(x^3 - x + 2, 'a')
+            sage: OK = K.ring_of_integers()
+            sage: (OK.1).canonical_associate()
+            NotImplemented
+        """
+        return NotImplemented
+
 
 cdef class OrderElement_relative(NumberFieldElement_relative):
     """
@@ -5524,6 +5578,24 @@ cdef class OrderElement_relative(NumberFieldElement_relative):
         R = ZZ[var]
         return R(K(self).absolute_minpoly(var))
 
+    def canonical_associate(self):
+        """
+        Return a canonical associate.
+
+        Only implemented here because order elements inherit from
+        field elements, but the canonical associate implemented there
+        does not apply here.
+
+        EXAMPLES::
+
+            sage: x = ZZ['x'].0
+            sage: K.<a,b> = NumberField([x^2 + 1, x^2 - 3])
+            sage: OK = K.maximal_order()
+            sage: (OK.1).canonical_associate()
+            NotImplemented
+        """
+        return NotImplemented
+
 
 class CoordinateFunction():
     r"""

sage/rings/number_field/number_field_element_quadratic.pyx

@@ -420,7 +420,7 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         """
         Used for pickling.
 
-        TESTS:
+        TESTS::
 
             sage: x = polygen(ZZ, 'x')
             sage: K.<a> = NumberField(x^2 - 13)
@@ -438,6 +438,23 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         return __make_NumberFieldElement_quadratic1, (self._parent, type(self), a, b, denom)
 
     cdef int _randomize(self, num_bound, den_bound, distribution) except -1:
+        """
+        TESTS::
+
+            sage: a = ZZ.random_element(-100, 100)
+            sage: while a.is_square():
+            ....:     a = ZZ.random_element(-100, 100)
+            sage: K = QuadraticField(a)
+            sage: K.random_element().parent() is K  # indirect doctest
+            True
+            sage: len(set(K.random_element() for _ in range(100))) >= 40
+            True
+
+        Verify that :issue:`30017` is fixed::
+
+            sage: all(K.random_element().is_integral() for s in range(100))
+            False
+        """
         cdef Integer temp, denom1, denom2
 
         # in theory, we could just generate two random numerators and
@@ -448,17 +465,20 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         # of the random element code, it's worth doing slightly more
         # work to make this possible.
 
-        # normalize denominator bound
-        if den_bound is None or den_bound < 1:
-            den_bound = 1
-
         # generate denominators
-        denom1 = <Integer>(ZZ.random_element(x=1,
-                                             y=den_bound+1,
-                                             distribution=distribution))
-        denom2 = <Integer>(ZZ.random_element(x=1,
-                                             y=den_bound+1,
-                                             distribution=distribution))
+        if den_bound is None:
+            denom1 = <Integer>(1 + abs(ZZ.random_element(distribution=distribution)))
+            denom2 = <Integer>(1 + abs(ZZ.random_element(distribution=distribution)))
+        else:
+            # normalize denominator bound
+            if den_bound < 1:
+                den_bound = 1
+            denom1 = <Integer>(ZZ.random_element(x=1,
+                                                 y=den_bound+1,
+                                                 distribution=distribution))
+            denom2 = <Integer>(ZZ.random_element(x=1,
+                                                 y=den_bound+1,
+                                                 distribution=distribution))
 
         # set a, b
         temp = <Integer>(ZZ.random_element(x=num_bound, distribution=distribution))
@@ -2383,8 +2403,6 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
 
         TESTS::
 
-            sage: import warnings
-            sage: warnings.filterwarnings("ignore", category=DeprecationWarning)
             sage: K2.<sqrt2> = QuadraticField(2)
             sage: K3.<sqrt3> = QuadraticField(3)
             sage: K5.<sqrt5> = QuadraticField(5)
@@ -2399,15 +2417,15 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
             ....:    assert round(a+b*sqrt(5.)) == round(a+b*sqrt5), (a, b)
         """
         n = self.floor()
-        test = 2 * (self - n).abs()
+        test = 2 * (self - n)
         if test < 1:
             return n
         elif test > 1:
             return n + 1
-        elif self > 0:
-            return n + 1
-        else:
+        elif n % 2 == 0:
             return n
+        else:
+            return n + 1
 
 
 cdef class NumberFieldElement_quadratic_sqrt(NumberFieldElement_quadratic):