Ticket #3910: trac3910-interval-integers.patch

a/sage/calculus/calculus.py

@@ -4844 +4844 @@
-            sage: AA(-golden_ratio)
-            -1.618033988749895?
-            sage: QQbar((2*I)^(1/2))
-.0000000000000000? + 1.0000000000000000?
+ + 1
-
-        TESTS:
-            sage: AA(x*sin(0))

a/sage/rings/complex_interval.pyx

@@ -407 +407 @@
-        EXAMPLES:
-            sage: C.<i> = ComplexIntervalField(20)
-            sage: a = i^2; a
-.0000000?
+
-            sage: a.parent()
-            Complex Interval Field with 20 bits of precision
-            sage: a = (1+i)^7; a
-.0000000? - 8.0000000?
+ - 8
-            sage: (1+i)^(1+i)
-            0.27396? + 0.58370?*I
-            sage: a.parent()
@@ -450 +450 @@
-            sage: i = ComplexIntervalField(100).0
-            sage: z = 2 + 3*i
-            sage: x = z.real(); x
-.0000000000000000000000000000000?
+
-            sage: x.parent()
-            Real Interval Field with 100 bits of precision
-        """
@@ -467 +467 @@
-            sage: i = ComplexIntervalField(100).0
-            sage: z = 2 + 3*i
-            sage: x = z.imag(); x
-.0000000000000000000000000000000?
+
-            sage: x.parent()
-            Real Interval Field with 100 bits of precision
-        """
@@ -611 +611 @@
-            sage: (RR('-0.001') - i).argument()
-            -1.571796326461564?
-            sage: CIF(2).argument()
-.?e-17
+
-            sage: CIF(-2).argument()
-            3.141592653589794?
-
@@ -718 +718 @@
-        EXAMPLES:
-            sage: i = CIF.0
-            sage: (1+i).conjugate()
-.0000000000000000? - 1.0000000000000000?
+ - 1
-        """
-        cdef ComplexIntervalFieldElement x
-        x = self._new()
@@ -874 +874 @@
-        sage: ComplexIntervalFieldElement('2.3','1.1')
-        2.300000000000000? + 1.1000000000000000?*I
-        sage: ComplexIntervalFieldElement(10)
-.000000000000000?
+
-        sage: ComplexIntervalFieldElement(10,10)
-.000000000000000? + 10.000000000000000?
+ + 10
-        sage: ComplexIntervalFieldElement(1.000000000000000000000000000,2)
-.00000000000000000000000000000? + 2.00000000000000000000000000000?
+ + 2
-        sage: ComplexIntervalFieldElement(1,2.000000000000000000000)
-
+
+
+
-    """
-    if s_imag is None:
-        s_imag = 0

a/sage/rings/complex_interval_field.py

@@ -57 +57 @@
-        Real Interval Field with 100 bits of precision
-        sage: i = ComplexIntervalField(200).gen()
-        sage: i^2
-
+
+
+
-    """
-    global cache
-    if cache.has_key(prec):
@@ -81 +83 @@
-        sage: C(1/3)
-        0.3333333333333334?
-        sage: C(1/3, 2)
-.0000000000000000?
+
-
-    We can also coerce rational numbers and integers into C, but
-    coercing a polynomial will raise an exception.
@@ -172 +174 @@
-        """
-        EXAMPLES:
-            sage: CIF(2)
-.0000000000000000?
+
-            sage: CIF(CIF.0)
-.0000000000000000?
+
-            sage: CIF('1+I')
-.0000000000000000? + 1.0000000000000000?
+ + 1
-            sage: CIF(2,3)
-
+
+
+
-        """
-        if im is None:
-            if isinstance(x, complex_interval.ComplexIntervalFieldElement) and x.parent() is self:

a/sage/rings/polynomial/complex_roots.py

@@ -45 +45 @@
-        sage: x = polygen(ZZ)
-        sage: p = x^9 - 1
-        sage: ip = CIF['x'](p); ip
-1.0000000000000000?*x^9 - 1.0000000000000000?
+x^9 - 1
-        sage: ipd = CIF['x'](p.derivative()); ipd
-.0000000000000000?
+
-        sage: irt = CIF(CC(cos(2*pi/9), sin(2*pi/9))); irt
-        0.76604444311897802? + 0.64278760968653926?*I
-        sage: ip(irt)
@@ -158 +158 @@
-        sage: rts = [CC.zeta(3)^i for i in range(0, 3)]
-        sage: from sage.rings.polynomial.complex_roots import interval_roots
-        sage: interval_roots(p, rts, 53)
-.0000000000000000?
+
-        sage: interval_roots(p, rts, 200)
-.0000000000000000000000000000000000000000000000000000000000000?
+
-    """
-
-    CIF = ComplexIntervalField(prec)

a/sage/rings/polynomial/multi_polynomial_ideal.py

@@ -1440 +1440 @@
-             {y: 1.00000000000000, x: 1.00000000000000}]
-            sage: I.variety(ring=AA)
-            [{x: 2.769292354238632?, y: 0.3611030805286474?}, 
-.0000000000000000?, y: 1.0000000000000000?
+, y: 1
-
-        and a total of four intersections:
-
@@ -1457 +1457 @@
-             {x: 0.11535382288068429? - 0.5897428050222055?*I, 
-              y: 0.3194484597356763? + 1.633170240915238?*I}, 
-             {x: 2.769292354238632?, y: 0.3611030805286474?}, 
-.0000000000000000?, y: 1.0000000000000000?
+, y: 1
-
-        TESTS:
-            sage: K.<w> = GF(27)

a/sage/rings/polynomial/real_roots.pyx

@@ -3781 +3781 @@
-        sage: real_roots(x*(x-1)*(x-2), bounds=(0, 2))
-        [((0, 0), 1), ((81/128, 337/256), 1), ((2, 2), 1)]
-        sage: real_roots(x*(x-1)*(x-2), bounds=(0, 2), retval='algebraic_real')
-.?e-17, 1), (1.0000000000000000?, 1), (2.0000000000000000?
+, 1), (1, 1), (2
-        sage: v = 2^40
-        sage: real_roots((x^2-1)^2 * (x^2 - (v+1)/v))
-        [((-12855504354077768210885019021174120740504020581912910106032833/12855504354071922204335696738729300820177623950262342682411008, -6427752177038884105442509510587059395588605840418680645585479/6427752177035961102167848369364650410088811975131171341205504), 1), ((-1125899906842725/1125899906842624, -562949953421275/562949953421312), 2), ((62165404551223330269422781018352603934643403586760330761772204409982940218804935733653/62165404551223330269422781018352605012557018849668464680057997111644937126566671941632, 3885337784451458141838923813647037871787041539340705594199885610069035709862106085785/3885337784451458141838923813647037813284813678104279042503624819477808570410416996352), 2), ((509258994083853105745586001837045839749063767798922046787130823804169826426726965449697819/509258994083621521567111422102344540262867098416484062659035112338595324940834176545849344, 25711008708155536421770038042348240136257704305733983563630791/25711008708143844408671393477458601640355247900524685364822016), 1)]
@@ -3808 +3808 @@
-        sage: real_roots((x+3)*(x+1)*x*(x-1)*(x-2), strategy='warp')
-        [((-1713/335, -689/335), 1), ((-2067/2029, -689/1359), 1), ((0, 0), 1), ((499/525, 1173/875), 1), ((337/175, 849/175), 1)]
-        sage: real_roots((x+3)*(x+1)*x*(x-1)*(x-2), strategy='warp', retval='algebraic_real')
-.?e-17
+
-        sage: ar_rts = real_roots(x-1, retval='algebraic_real')
-        sage: ar_rts[0][0] == 1
-        True

a/sage/rings/qqbar.py

@@ -130 +130 @@
-    sage: AA((-8)^(1/3))
-    -2
-    sage: QQbar((-4)^(1/4))
-.0000000000000000? + 1.0000000000000000?
+ + 1
-    sage: AA((-4)^(1/4))
-    Traceback (most recent call last):
-    ...
@@ -366 +366 @@
-    sage: convert_test_all(CC)
-    [42.0000000000000, 3.14285714285714, 1.61803398874989, -13.0000000000000, 1.61818181818182, -2.64575131106459, 0.309016994374947 + 0.951056516295154*I]
-    sage: convert_test_all(RIF)
-.000000000000000?, 3.142857142857143?, 1.618033988749895?, -13.000000000000000?
+, 3.142857142857143?, 1.618033988749895?, -13
-    sage: convert_test_all(CIF)
-.000000000000000?, 3.142857142857143?, 1.618033988749895?, -13.000000000000000?
+, 3.142857142857143?, 1.618033988749895?, -13
-    sage: convert_test_all(ZZ)
-    [42, None, None, -13, None, None, None]
-    sage: convert_test_all(QQ)
@@ -726 +726 @@
-            sage: p = (x-1)^7 * (x-2)
-            sage: r = QQbar.polynomial_root(p, RIF(9/10, 11/10), multiplicity=7)
-            sage: r; r == 1
-.0000000000000000?
+
-            True
-            sage: p = (x-phi)*(x-sqrt(QQbar(2)))
-            sage: r = QQbar.polynomial_root(p, RIF(1, 3/2))
@@ -1253 +1253 @@
-        sage: nf = NumberField(y^2 + 1, name='a', check=False)
-        sage: root = ANRoot(x^2 + 1, CIF(0, 1))
-        sage: x = AlgebraicGenerator(nf, root); x        
-.0000000000000000?
+
-        """
-        self._field = field
-        self._pari_field = None
@@ -2792 +2792 @@
-
-        EXAMPLES:
-            sage: QQbar(3 + 4*I).conjugate()
-.0000000000000000? - 4.0000000000000000?
+ - 4
-            sage: QQbar.zeta(7).conjugate()
-            0.6234898018587335? - 0.7818314824680299?*I
-            sage: QQbar.zeta(7) + QQbar.zeta(7).conjugate()
@@ -2878 +2878 @@
-            sage: a = QQbar.zeta(9) + I + QQbar.zeta(9).conjugate(); a
-            1.532088886237957? + 1.000000000000000?*I
-            sage: a.complex_exact(CIF)
-.0000000000000000?
+
-        """
-        rfld = field._real_field()
-        re = self.real().real_exact(rfld)
@@ -3213 +3213 @@
-            sage: y.interval(RIF)
-            2.000000000000000?
-            sage: y.interval_exact(RIF)
-.0000000000000000?
+
-            sage: z = 1 + AA(2).sqrt() / 2^200
-            sage: z.interval(RIF)
-            1.000000000000001?
@@ -4492 +4492 @@
-
-        EXAMPLES:
-            sage: a = AA(sqrt(2)) + QQbar(I); a
-.0000000000000000?
+
-            sage: p = a.minpoly(); p
-            x^4 - 2*x^2 + 9
-            sage: p(a)

a/sage/rings/real_mpfi.pyx

@@ -36 +36 @@
-
-    sage: RIF(sqrt(2))
-    1.414213562373095?
+
+However, if the interval is precise (its lower bound is equal to its
+upper bound) and equal to a not-too-large integer, then we just print that
+integer.
+
+    sage: RIF(0)
+    0
+    sage: RIF(654321)
+    654321
+
-    sage: RIF(123, 125)
-    124.?
-    sage: RIF(123, 126)
@@ -62 +72 @@
-Error digits also sometimes let us indicate that the interval is actually
-equal to a single floating-point number.
-
-124
-124.00000000
-124
-124.00000000
+54321/256
+212.19140625
+54321/256
+212.19140625
-
-In brackets style, intervals are printed with the left value rounded
-down and the right rounded up, which is conservative, but in some ways
@@ -239 +249 @@
-        sage: RIF = RealIntervalField(); RIF
-        Real Interval Field with 53 bits of precision
-        sage: RIF(3)
-.0000000000000000?
+
-        sage: RIF(RIF(3))
-.0000000000000000?
+
-        sage: RIF(pi)
-        3.141592653589794?
-        sage: RIF(RealField(53)('1.5'))
@@ -249 +259 @@
-        sage: RIF(-2/19)
-        -0.10526315789473684?
-        sage: RIF(-3939)
-.0000000000000?
+
-        sage: RIF(-3939r)
-.0000000000000?
+
-        sage: RIF('1.5')
-        1.5000000000000000?
-        sage: RIF(RQDF.pi())
@@ -262 +272 @@
-
-    The base must be explicitly specified as a named parameter:
-        sage: RIF('101101', base=2)
-.000000000000000?
+
-        sage: RIF('+infinity')
-        [+infinity .. +infinity]
-        sage: RIF('[1..3]').str(style='brackets')
@@ -323 +333 @@
-    Some examples with a real interval field of higher precision:
-        sage: R = RealIntervalField(100)
-        sage: R(3)
-.0000000000000000000000000000000?
+
-        sage: R(R(3))
-.0000000000000000000000000000000?
+
-        sage: R(pi)
-        3.14159265358979323846264338328?
-        sage: R(-2/19)
@@ -676 +686 @@
-        EXAMPLES:
-            sage: R = RealIntervalField()
-            sage: R.zeta()
-.0000000000000000?
+
-            sage: R.zeta(1)
-.0000000000000000?
+
-            sage: R.zeta(5)
-            Traceback (most recent call last):
-            ...
@@ -950 +960 @@
-        sage: RIF(pi, 22/7).str(style='question')
-        '3.142?'
-
+        However, if the interval is precisely equal to some integer that's
+        not too large, we just return that integer.
+
+        sage: RIF(-42).str()
+        '-42'
+        sage: RIF(0).str()
+        '0'
+        sage: RIF(12^5).str(base=3)
+        '110122100000'
+
+        Very large integers, however, revert to the normal question-style
+        printing.
+
+        sage: RIF(3^7).str()
+        '2187'
+        sage: RIF(3^7 * 2^256).str()
+        '2.5323729916201052?e80'
+
-        In brackets style, we print the lower and upper bounds of the
-        interval within brackets:
-
@@ -1064 +1092 @@
-            1.732050807568878?
-            sage: RIF(3).sqrt()
-            1.732050807568878?
+            sage: RIF(0, 3^-150)
+            1.?e-71
-        """
-        if base < 2 or base > 36:
-            raise ValueError, "the base (=%s) must be between 2 and 36"%base
@@ -1220 +1250 @@
-            14142.13562373095?
-            141421.3562373095?
-            1.414213562373095?e6
+            sage: RIF(3^33)
+            5559060566555523
+            sage: RIF(3^33 * 2)
+            1.1118121133111046?e16
+            sage: RIF(-pi^-512, 0)
+            -1.?e-254
+            sage: RealIntervalField(2)(3 * 2^18)
+            786432
+            sage: RealIntervalField(2)(3 * 2^19)
+            1.6?e6
-        """
-        if not(mpfr_number_p(&self.value.left) and mpfr_number_p(&self.value.right)):
-            raise ValueError, "_str_question_style on NaN or infinity"
@@ -1237 +1277 @@
-            # error digits; 1000 error digits is just silly.
-            raise ValueError, "error_digits (=%s) must be between 0 and 1000"%error_digits
-            
+        cdef mp_exp_t self_exp
+        cdef mpz_t self_zz
+        cdef int prec = (<RealIntervalField>self._parent).__prec
+        cdef char *zz_str
+        cdef size_t zz_str_maxlen
+        
+        if mpfr_equal_p(&self.value.left, &self.value.right) \
+                and mpfr_integer_p(&self.value.left):
+            # This might be suitable for integer printing, but not if it's
+            # too big.  (We can represent 2^3000000 exactly in RIF, but we
+            # don't want to print this 903090 digit number; we'd rather
+            # just print 9.7049196389007116?e903089 .)
+
+            # Represent self as m*2^k, where m is an integer with
+            # self.prec() bits and k is an integer.  (So RIF(1) would have
+            # m = 2^52 and k=-52.)  Then, as a simple heuristic, we print
+            # as an integer if k<=0.  (As a special dispensation for tiny
+            # precisions, we also print as an integer if the number is
+            # less than a million (actually, less than 2^20); this 
+            # will never affect "normal" uses, but it makes tiny examples
+            # with RealIntervalField(2) prettier.)
+
+            self_exp = mpfr_get_exp(&self.value.left)
+            if mpfr_zero_p(&self.value.left) or self_exp <= prec or self_exp <= 20:
+                mpz_init(self_zz)
+                mpfr_get_z(self_zz, &self.value.left, GMP_RNDN)
+                zz_str_maxlen = mpz_sizeinbase(self_zz, base) + 2
+                zz_str = <char *>PyMem_Malloc(zz_str_maxlen)
+                if zz_str == NULL:
+                    mpz_clear(self_zz)
+                    raise MemoryError, "Unable to allocate memory for integer representation of interval"
+                _sig_on
+                mpz_get_str(zz_str, base, self_zz)
+                _sig_off
+                v = PyString_FromString(zz_str)
+                PyMem_Free(zz_str)
+                return v
+
-        # We want the endpoints represented as an integer mantissa
-        # and an exponent, using the given base.  MPFR will do that for
-        # us in mpfr_get_str, so we end up converting from MPFR to strings
@@ -1308 +1386 @@
-        # exponents are sufficiently different, the simple code would
-        # involve computing a huge power of base, and then dividing
-        # by it to get -1, 0, or 1 (depending on the rounding).
+
+        # There's one complication first: if one of the endpoints is zero,
+        # we want to treat it as infinitely precise (otherwise, it defaults
+        # to a precision of 2^-self.prec(), so that RIF(0, 2^-1000)
+        # would print as 1.?e-17).  (If both endpoints are zero, then
+        # we can't get here; we already returned '0' in the integer
+        # case above.)
+
+        if mpfr_zero_p(&self.value.left):
+            lower_expo = upper_expo
+        if mpfr_zero_p(&self.value.right):
+            upper_expo = lower_expo
-
-        cdef int expo_delta
-
@@ -1784 +1874 @@
-        EXAMPLES:
-            sage: R = RealIntervalField()
-            sage: R(-1.5) + R(2.5)
-.0000000000000000?
+
-            sage: R('-1.3') + R('2.3')
-            1.000000000000000?
-            sage: (R(1, 2) + R(3, 4)).str(style='brackets')
@@ -1803 +1893 @@
-
-        EXAMPLES:
-            sage: v = RIF(2); v
-.0000000000000000?
+
-            sage: ~v
-            0.50000000000000000?
-            sage: v * ~v
-.0000000000000000?
+
-            sage: v = RIF(1.5, 2.5); v.str(style='brackets')
-            '[1.5000000000000000 .. 2.5000000000000000]'
-            sage: (~v).str(style='brackets')
@@ -1829 +1919 @@
-        EXAMPLES:
-            sage: R = RealIntervalField()
-            sage: R(-1.5) - R(2.5)
-.0000000000000000?
+
-            sage: R('-1.3') - R('2.7')
-            -4.000000000000000?
-            sage: (R(1, 2) - R(3, 4)).str(style='brackets')
@@ -1909 +1999 @@
-
-        EXAMPLES:
-            sage: v = RIF(2); v
-.0000000000000000?
+
-            sage: -v
-.0000000000000000?
+
-            sage: v + -v
-.?e-17
+
-            sage: v = RIF(1.5, 2.5); v.str(error_digits=3)
-            '2.000?500'
-            sage: (-v).str(style='brackets')
@@ -1972 +2062 @@
-
-        EXAMPLES:
-            sage: RIF(1.0) << 32
-.2949672960000000?e9
+294967296
-        """
-        if isinstance(x, RealIntervalFieldElement) and isinstance(y, (int,long, Integer)):
-            return x._lshift_(y)
@@ -2688 +2778 @@
-        EXAMPLES:
-            sage: r = RIF(4.0)
-            sage: r.sqrt()
-.0000000000000000?
+
-            sage: r.sqrt()^2 == r
-            True
-
@@ -2708 +2798 @@
-            sage: r.sqrt()
-            Traceback (most recent call last):
-            ...
-.0000000000000000?
+
-
-            sage: r = RIF(-2, 2)
-            sage: r.sqrt()
@@ -2733 +2823 @@
-            sage: r.sqrt()
-            Traceback (most recent call last):
-            ...
-.0000000000000000?
+
-        """
-        cdef RealIntervalFieldElement x
-        x = self._new()
@@ -2836 +2926 @@
-        EXAMPLES:
-            sage: r = RIF(16.0)
-            sage: r.log2()
-.0000000000000000?
+
-
-            sage: r = RIF(31.9); r.log2()
-            4.995484518877507?
@@ -2888 +2978 @@
-        EXAMPLES:
-            sage: r = RIF(0.0)
-            sage: r.exp()
-.0000000000000000?
+
-
-            sage: r = RIF(32.3)
-            sage: a = r.exp(); a
@@ -2914 +3004 @@
-        EXAMPLES:
-            sage: r = RIF(0.0)
-            sage: r.exp2()
-.0000000000000000?
+
-            
-            sage: r = RIF(32.0)
-            sage: r.exp2()
-.2949672960000000?e9
+294967296
-
-            sage: r = RIF(-32.3)
-            sage: r.exp2()
@@ -3499 +3589 @@
-        sage: RealInterval('2.3')
-        2.300000000000000?
-        sage: RealInterval(10)
-.000000000000000?
+
-        sage: RealInterval('1.0000000000000000000000000000000000')
-
+
+
+
-        sage: RealInterval(29308290382930840239842390482, 3^20).str(style='brackets')
-        '[3.48678440100000000000000000000e9 .. 2.93082903829308402398423904820e28]'
-    """