Ticket #7682: trac-7682-realfield-printing-options.patch

File trac-7682-realfield-printing-options.patch, 57.3 KB (added by jason, 11 years ago)
  • sage/calculus/calculus.py

    # HG changeset patch
    # User Jason Grout <jason-sage@creativetrax.com>
    # Date 1264426711 21600
    # Node ID d6741a60d325a83d65ffbdd655baff008586aba9
    # Parent  14eeb0ac9d41bb564d5867eda84d6de920e68c29
    Added a more comprehensive print options feature to RealField.
    
    Fixed lots and lots of docstrings
    
    Fixed the bug: RR('inf').is_unit() returns True
    
    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/calculus/calculus.py
    a b  
    12491249                            elif epsilon and error < epsilon:
    12501250                                return g
    12511251                            elif algorithm is not None:
    1252                                 raise NotImplementedError, "Could not prove minimal polynomial %s (epsilon %s)" % (g, RR(error).str(no_sci=False))
     1252                                raise NotImplementedError, "Could not prove minimal polynomial %s (epsilon %s)" % (g, RR(error).str(scientific_notation='always'))
    12531253
    12541254        if algorithm is not None:
    12551255            raise ValueError, "Could not find minimal polynomial (%s bits, degree %s)." % (bits, degree)
     
    19381938    search = sci_not.search(s)
    19391939    while not search is None:
    19401940        (start, end) = search.span()
    1941         r = create_RealNumber(s[start:end]).str(no_sci=2, truncate=True)
     1941        r = create_RealNumber(s[start:end]).str(scientific_notation='never', truncate=True)
    19421942        s = s.replace(s[start:end], r)
    19431943        search = sci_not.search(s)
    19441944     
  • sage/calculus/desolvers.py

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/calculus/desolvers.py
    a b  
    652652        sage: x,y = PolynomialRing(QQ,2,"xy").gens()
    653653        sage: eulers_method(5*x+y-5,0,1,1/2,1,method="none")
    654654        [[0, 1], [1/2, -1], [1, -11/4], [3/2, -33/8]]
    655         sage: RR = RealField(sci_not=0, prec=4, rnd='RNDU')
     655        sage: RR = RealField(prec=4, rnd='RNDU', print_options={'scientific_notation': 0})
    656656        sage: x,y = PolynomialRing(RR,2,"xy").gens()
    657657        sage: eulers_method(5*x+y-5,0,1,1/2,1,method="None")
    658658        [[0, 1], [1/2, -1.0], [1, -2.7], [3/2, -4.0]]
    659         sage: RR = RealField(sci_not=0, prec=4, rnd='RNDU')
     659        sage: RR = RealField(prec=4, rnd='RNDU', print_options={'scientific_notation': 0})
    660660        sage: x,y=PolynomialRing(RR,2,"xy").gens()
    661661        sage: eulers_method(5*x+y-5,0,1,1/2,1)
    662662             x                    y                  h*f(x,y)
     
    719719           1/3                    0                       1/9                    0                    0
    720720           2/3                  1/9                      7/27                    0                 1/27
    721721             1                10/27                     38/81                 1/27                  1/9
    722         sage: RR = RealField(sci_not=0, prec=4, rnd='RNDU')
     722        sage: RR = RealField(prec=4, rnd='RNDU', print_options={'scientific_notation': 0})
    723723        sage: t,x,y=PolynomialRing(RR,3,"txy").gens()
    724724        sage: f = x+y+t; g = x-y
    725725        sage: eulers_method_2x2(f,g, 0, 0, 0, 1/3, 1)
     
    733733    using 4 steps of Euler's method, first convert to a system:
    734734    y1' = y2, y1(0)=1; y2' = (y1-y2)/(1+t^2), y2(0)=-1.
    735735
    736          sage: RR = RealField(sci_not=0, prec=4, rnd='RNDU')
     736         sage: RR = RealField(prec=4, rnd='RNDU', print_options={'scientific_notation': 0})
    737737         sage: t, x, y=PolynomialRing(RR,3,"txy").gens()
    738738         sage: f = y; g = (x-y)/(1+t^2)
    739739         sage: eulers_method_2x2(f,g, 0, 1, -1, 1/4, 1)
  • sage/misc/explain_pickle.py

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/misc/explain_pickle.py
    a b  
    210210        {('a', 'b'):[1r, 2r]}
    211211        sage: explain_pickle(dumps(RR(pi)), in_current_sage=True)
    212212        from sage.rings.real_mpfr import __create__RealNumber_version0
    213         from sage.rings.real_mpfr import __create__RealField_version0
    214         __create__RealNumber_version0(__create__RealField_version0(53r, False, 'RNDN'), '3.4gvml245kc0@0', 32r)
     213        from sage.rings.real_mpfr import __create__RealField_version1
     214        __create__RealNumber_version0(__create__RealField_version1(53r, 'RNDN', {'scientific_notation':'extreme', 'skip_zeroes':False, 'truncate':True}), '3.4gvml245kc0@0', 32r)
    215215        sage: s = 'hi'
    216216        sage: explain_pickle(dumps((s, s)))
    217217        ('hi', 'hi')
  • sage/misc/misc.py

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/misc/misc.py
    a b  
    19431943                  should be replaced.
    19441944
    19451945     - ``version`` - (optional) on which version and when the deprecation
    1946                   occured. Please put there the version of sageq at the time of deprecation.
     1946                  occured. Please put there the version of sage at the time of deprecation.
    19471947
    19481948    EXAMPLES::
    19491949
     
    19611961    # Stack level 3 to get the line number of the code which called
    19621962    # the deprecated function which called this function.
    19631963    if version is not None:
    1964         message = "(Since " + version + ") " + message
     1964        message = "(After " + version + ") " + message
    19651965    warn(message, DeprecationWarning, stacklevel=3)
    19661966
    19671967
     
    19691969from sage.misc.lazy_attribute import lazy_attribute
    19701970class DeprecatedFunctionAlias(object):
    19711971    """
    1972     A wrapper around methods or functions wich automatically print the correct
     1972    A wrapper around methods or functions which automatically print the correct
    19731973    deprecation message. See :func:`deprecated_function_alias`.
    19741974
    19751975    AUTHORS:
  • sage/rings/real_interval_field.py

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/rings/real_interval_field.py
    a b  
    1212    return isinstance(x, RealIntervalFieldElementClass)
    1313
    1414def __reduce__RealIntervalField(prec, sci_not):
    15     return RealIntervalField(prec, sci_not)
     15    print_options={'scientific_notation': sci_not}
     16    return RealIntervalField(prec=prec, print_options=print_options)
    1617
    1718def __reduce__RealIntervalFieldElement(parent, x, base=10):
    1819    return RealIntervalFieldElementClass(parent, x, base=base)
  • sage/rings/real_mpfi.pxd

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/rings/real_mpfi.pxd
    a b  
    1818
    1919cdef class RealIntervalField_class(sage.rings.ring.Field):
    2020    cdef int __prec
    21     cdef bint sci_not
     21    cdef object print_options
    2222    # Cache RealField instances for the lower, upper, and middle bounds.
    2323    # These have the same precision as the interval field;
    2424    # __lower_field rounds down, __upper_field rounds up.
  • sage/rings/real_mpfi.pyx

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/rings/real_mpfi.pyx
    a b  
    198198
    199199cimport real_mpfr
    200200from real_mpfr cimport RealField, RealNumber
    201 from real_mpfr import RealField_constructor
     201from real_mpfr import RealField_constructor, sci_not_deprecation
    202202import real_mpfr
    203203
    204204import operator
     
    227227printing_style = 'question'
    228228printing_error_digits = 0
    229229
     230_PRINT_OPTIONS = {'skip_zeroes': False, 'truncate': True, 'scientific_notation': 'extreme',
     231                  'style': 'question', 'error_digits': 0}
     232
     233
    230234#*****************************************************************************
    231235#
    232236#       Real Field
     
    237241
    238242RealIntervalField_cache = {}
    239243
    240 def RealIntervalField(prec=53, sci_not=False):
     244def RealIntervalField(prec=53, scientific_notation=None, print_options={},sci_not=None):
    241245    r"""
    242246    Construct a RealIntervalField_class, with caching.
    243247
     
    249253       mpfr_prec_min() and mpfr_prec_max(). In the current
    250254       implementation, mpfr_prec_min() is equal to 2.
    251255
    252     -  ``sci_not`` - (default: False) whether or not to display using
    253        scientific notation
     256    - ``scientific_notation``
     257
     258       - 'never' - never print using scientific notation;
     259
     260       - 'extreme' (default) - print using scientific notation only for very
     261         large or very small numbers;
     262
     263       - 'always' - always print with scientific notation;
    254264
    255265    EXAMPLES::
    256266
    257267        sage: RealIntervalField()
    258268        Real Interval Field with 53 bits of precision
    259         sage: RealIntervalField(200, sci_not=True)
     269        sage: RealIntervalField(200, scientific_notation=True)
    260270        Real Interval Field with 200 bits of precision
    261271        sage: RealIntervalField(53) is RIF
    262272        True
     
    268278    See the documentation for :class:`RealIntervalField_class` for many more
    269279    examples.
    270280    """
     281    printing=_PRINT_OPTIONS.copy()
     282    printing.update(print_options)
     283    if sci_not is not None:
     284        from sage.misc.misc import deprecation
     285        deprecation("The sci_not keyword is deprecated.  Use print_options={'scientific_notation': %r} instead."%sci_not_deprecation[sci_not])
     286        scientific_notation=sci_not_deprecation[sci_not]
     287    if scientific_notation is not None:
     288        printing['scientific_notation']=scientific_notation
     289    print_cached=tuple(sorted(printing.items()))
    271290    try:
    272         return RealIntervalField_cache[prec, sci_not]
     291        return RealIntervalField_cache[prec, print_cached]
    273292    except KeyError:
    274         RealIntervalField_cache[prec, sci_not] = R = RealIntervalField_class(prec, sci_not)
     293        RealIntervalField_cache[prec, print_cached] = R = RealIntervalField_class(prec=prec, print_options=printing, sci_not=sci_not)
    275294        return R
    276295
    277296cdef class RealIntervalField_class(sage.rings.ring.Field):
    278297    """
    279     RealIntervalField(prec, sci_not, rnd):
     298    RealIntervalField(prec, scientific_notation):
    280299   
    281300    INPUT:
    282301   
     
    288307       implementation, mpfr_prec_min() is equal to 2.
    289308   
    290309   
    291     -  ``sci_not`` - (default: False) whether or not to display using
     310    -  ``scientific_notation`` - (default: False) whether or not to display using
    292311       scientific notation
    293312   
    294313    EXAMPLES::
     
    433452        sage: RIF._middle_field() is RR
    434453        True
    435454    """
    436 
    437     def __init__(self, int prec=53, int sci_not=0):
     455    def __init__(self, int prec=53, scientific_notation=None, print_options=None, sci_not=None):
     456        if sci_not is not None:
     457            from sage.misc.misc import deprecation
     458            deprecation("The sci_not keyword is deprecated.  Use scientific_notation instead.")
     459            scientific_notation=sci_not
     460       
    438461        if prec < MPFR_PREC_MIN or prec > MPFR_PREC_MAX:
    439462            raise ValueError, "prec (=%s) must be >= %s and <= %s."%(
    440463                prec, MPFR_PREC_MIN, MPFR_PREC_MAX)
    441464        self.__prec = prec
    442         self.sci_not = sci_not
    443         self.__lower_field = RealField_constructor(prec, sci_not, "RNDD")
    444         self.__middle_field = RealField_constructor(prec, sci_not, "RNDN")
    445         self.__upper_field = RealField_constructor(prec, sci_not, "RNDU")
     465        self.print_options=_PRINT_OPTIONS.copy()
     466        if scientific_notation is not None:
     467            self.print_options['scientific_notation']=scientific_notation
     468
     469        realfield_print_options={}
     470        for key in real_mpfr._PRINT_OPTIONS:
     471            if key in self.print_options:
     472                realfield_print_options[key]=self.print_options[key]
     473
     474        self.__lower_field = RealField_constructor(prec=prec, rnd="RNDD",
     475                                                   print_options=realfield_print_options)
     476        self.__middle_field = RealField_constructor(prec=prec, rnd="RNDN",
     477                                                    print_options=realfield_print_options)
     478        self.__upper_field = RealField_constructor(prec=prec, rnd="RNDU",
     479                                                   print_options=realfield_print_options)
    446480        ParentWithGens.__init__(self, self, tuple([]), False)
    447481
    448482    def _lower_field(self):
     
    462496        elif rnd == "RNDU":
    463497            return self._upper_field()
    464498        else:
    465             return RealField_constructor(self.__prec, self.sci_not, "RNDZ")
     499            return RealField_constructor(prec=self.__prec, rnd="RNDZ",
     500                                         print_options=self.print_options)
    466501
    467502    cdef RealIntervalFieldElement _new(self):
    468503        """
     
    583618        from sage.categories.pushout import CompletionFunctor
    584619        return (CompletionFunctor(sage.rings.infinity.Infinity,
    585620                                  self.prec(),
    586                                   {'sci_not': self.scientific_notation(), 'type': 'Interval'}),
     621                                  {'print_options': self.print_options, 'type': 'Interval'}),
    587622               sage.rings.rational_field.QQ)
    588623
    589624    cdef _coerce_c_impl(self, x):
     
    638673            False
    639674            sage: RealIntervalField(10) == RealIntervalField(10)
    640675            True
    641             sage: RealIntervalField(10,sci_not=True) == RealIntervalField(10,sci_not=False)
     676            sage: RealIntervalField(10,scientific_notation=True) == RealIntervalField(10,scientific_notation=False)
    642677            True
    643678            sage: RealIntervalField(10) == IntegerRing()
    644679            False
     
    655690        """
    656691        EXAMPLES::
    657692       
    658             sage: R = RealIntervalField(sci_not=1, prec=200)
     693            sage: R = RealIntervalField(scientific_notation=1, prec=200)
    659694            sage: loads(dumps(R)) == R
    660695            True
    661696        """
    662         return __create__RealIntervalField_version0, (self.__prec, self.sci_not)
     697        return __create__RealIntervalField_version1, (self.__prec, self.print_options)
    663698
    664699    def random_element(self, *args):
    665700        """
     
    881916       
    882917        -  ``status`` - (bool -) optional flag
    883918        """
     919        from sage.misc.misc import deprecation
    884920        if status is None:
    885             return self.sci_not
    886         else:
    887             self.sci_not = status
     921            deprecation("scientific_notation() is deprecated.  Use self.print_options['scientific_notation'] instead")
     922            return self.print_options['scientific_notation']
     923        else:
     924            deprecation("scientific_notation() is deprecated.  Use self.print_options['scientific_notation']=value instead")
     925            self.print_options['scientific_notation'] = status
    888926       
    889927    def zeta(self, n=2):
    890928        """
     
    10591097            sage: a = RIF(5,5.5)
    10601098            sage: cmp(loads(dumps(a)), a)
    10611099            0       
    1062             sage: R = RealIntervalField(sci_not=1, prec=200)
     1100            sage: R = RealIntervalField(scientific_notation=1, prec=200)
    10631101            sage: b = R('393.39203845902384098234098230948209384028340')
    10641102            sage: cmp(loads(dumps(b)), b)
    10651103            0
     
    10761114            sage: cmp(loads(dumps(b)), b)
    10771115            0
    10781116        """
    1079         s = self.str(32, style='brackets', no_sci=False, e='@')
     1117        s = self.str(32, style='brackets', scientific_notation='always', e='@')
    10801118        return (__create__RealIntervalFieldElement_version0, (self._parent, s, 32))
    10811119
    10821120    def  __dealloc__(self):
     
    11951233        """
    11961234        return self._parent
    11971235
    1198     # MPFR had an elaborate "truncation" scheme to avoid printing
    1199     # inaccurate-looking results; this has been removed for MPFI,
     1236    # RealField had an elaborate "truncation" scheme to avoid printing
     1237    # inaccurate-looking results; this has been removed for RealIntervalField,
    12001238    # because I think it's less confusing to get such results than to
    12011239    # see [0.333 .. 0.333] for an interval with unequal left and right
    12021240    # sides.
    1203     def str(self, int base=10, style=None, no_sci=None, e=None, error_digits=None):
     1241    def str(self, int base=10, style=None, no_sci=None, e=None, error_digits=None,scientific_notation=None):
    12041242        r"""
    12051243        INPUT:
    12061244       
     
    13461384            '[2.1851851851851851 .. 2.1851851851851856]'
    13471385            sage: a.str(16)
    13481386            '2.2f684bda12f69?'
    1349             sage: a.str(no_sci=False)
     1387            sage: a.str(scientific_notation='always')
    13501388            '2.185185185185186?e0'
    13511389            sage: pi_appr = RIF(pi, 22/7)
    13521390            sage: pi_appr.str(style='brackets')
     
    13841422            else:
    13851423                return "[.. NaN ..]"
    13861424       
     1425
     1426        if no_sci is not None:
     1427            from sage.misc.misc import deprecation
     1428            deprecated_option = {True: 'extreme', False: 'always'}
     1429            deprecation("The no_sci keyword is deprecated.  Use scientific_notation=%r instead."%deprecated_option[no_sci])
     1430            scientific_notation=deprecated_option[no_sci]
     1431        if scientific_notation not in [None, 'always','extreme']:
     1432            raise ValueError, "scientific_notation must be one of 'always', 'extreme', or 'never'."
     1433        elif scientific_notation is None:
     1434            scientific_notation = (<RealIntervalField_class>self._parent).print_options.get('scientific_notation',_PRINT_OPTIONS['scientific_notation'])
     1435       
     1436
     1437
    13871438        if e is None:
    13881439            if base > 10:
    13891440                e = '@'
     
    13991450            style = 'brackets'
    14001451
    14011452        if style == 'brackets':
    1402             t1 = self.lower().str(base=base, no_sci=no_sci, e=e, truncate=False)
    1403             t2 = self.upper().str(base=base, no_sci=no_sci, e=e, truncate=False)
     1453            t1 = self.lower().str(base=base, scientific_notation=scientific_notation, e=e, truncate=False)
     1454            t2 = self.upper().str(base=base, scientific_notation=scientific_notation, e=e, truncate=False)
    14041455
    14051456            return "[%s .. %s]"%(t1, t2)
    14061457       
    14071458        elif style == 'question':
    1408             if no_sci == False:
     1459            if scientific_notation=='always':
    14091460                prefer_sci = True
    1410             else:
     1461            elif scientific_notation=='extreme':
    14111462                prefer_sci = False
     1463            else:
     1464                raise ValueError, "scientific_notation must be 'always' or 'extreme'"
    14121465            return self._str_question_style(base, error_digits, e, prefer_sci)
    14131466
    14141467        else:
     
    41614214
    41624215
    41634216#### pickle functions
     4217def __create__RealIntervalField_version1(prec, print_options):
     4218    return RealIntervalField(prec=prec, print_options=print_options)
     4219
    41644220def __create__RealIntervalField_version0(prec, sci_not):
    4165     return RealIntervalField(prec, sci_not)
     4221    print_options={'scientific_notation': sci_not}
     4222    return RealIntervalField(prec=prec, print_options=print_options)
    41664223
    41674224## Keep all old versions!!!
    41684225def __create__RealIntervalFieldElement_version0(parent, x, base=10):
  • sage/rings/real_mpfr.pxd

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/rings/real_mpfr.pxd
    a b  
    1616
    1717cdef class RealField(sage.rings.ring.Field):
    1818    cdef int __prec
    19     cdef bint sci_not
     19    cdef object print_options
    2020    cdef mpfr_rnd_t rnd
    2121    cdef object rnd_str
    2222    cdef RealNumber _new(self)
  • sage/rings/real_mpfr.pyx

    diff -r 14eeb0ac9d41 -r d6741a60d325 sage/rings/real_mpfr.pyx
    a b  
    2424
    2525- Robert Bradshaw (2009-09): decimal literals, optimizations
    2626
     27- Jason Grout (2010-01): unified printing option defaults
     28
    2729This is a binding for the MPFR arbitrary-precision floating point
    2830library.
    2931
     
    194196
    195197_rounding_modes = ['RNDN', 'RNDZ', 'RNDU', 'RNDD']
    196198
     199_PRINT_OPTIONS = {'skip_zeroes': False, 'truncate': True, 'scientific_notation': 'extreme'}
     200
     201# Remove sci_not_deprecation when removing the sci_not deprecation warnings
     202sci_not_deprecation = {0: 'extreme', False: 'extreme', 1: 'always', True: 'always'}
     203
    197204cdef object RealField_cache = weakref.WeakValueDictionary()
    198205
    199 def RealField_constructor(int prec=53, int sci_not=0, rnd="RNDN"):
    200     """
    201     RealField(prec, sci_not, rnd):
     206def RealField_constructor(int prec=53, scientific_notation=None, rnd="RNDN", truncate=None,skip_zeroes=None, print_options=None, sci_not=None):
     207    """
     208    RealField(prec, scientific_notation, rnd):
    202209   
    203210    INPUT:
    204211   
     
    210217       implementation, mpfr_prec_min() is equal to 2.
    211218   
    212219   
    213     -  ``sci_not`` - (default: False) if True, always display using
    214        scientific notation; if False, display using scientific notation
    215        only for very large or very small numbers
     220    - ``scientific_notation``
     221
     222      - 'never' - never print using scientific notation;
     223
     224      - 'extreme' (default) - print using scientific notation only for
     225        very large or very small numbers;
     226
     227      - 'always' - always print with scientific notation;
    216228   
    217229    -  ``rnd`` - (string) the rounding mode
    218230
     
    226238
    227239      - RNDU - round towards plus infinity
    228240   
     241    - ``sci_not`` - deprecated.  See ``scientific_notation``.
     242
    229243    EXAMPLES::
    230244   
    231245        sage: RealField(10)
     
    243257       numbers (double type in C), except the default exponent range
    244258       is much wider and subnormal numbers are not implemented.'
    245259    """
     260    printing=_PRINT_OPTIONS.copy()
     261    if print_options is not None:
     262        printing.update(print_options)
     263    if sci_not is not None:
     264        from sage.misc.misc import deprecation
     265        deprecation("The sci_not keyword is deprecated.  Use scientific_notation=%r instead."%sci_not_deprecation[sci_not], 'Sage 4.3.2')
     266        scientific_notation=sci_not_deprecation[sci_not]
     267    if scientific_notation is not None:
     268        if scientific_notation not in ['always', 'extreme', 'never']:
     269            raise ValueError, "scientific_notation must be one of 'always', 'extreme', or 'never' (was %r)"%scientific_notation
     270        printing['scientific_notation']=scientific_notation
     271    if truncate is not None:
     272        printing['truncate']=truncate
     273    if skip_zeroes is not None:
     274        printing['skip_zeroes']=skip_zeroes
     275       
     276    print_cached=tuple(sorted(printing.items()))
    246277    try:
    247         return RealField_cache[prec, sci_not, rnd]
     278        return RealField_cache[prec, rnd, print_cached]
    248279    except KeyError:
    249         RealField_cache[prec, sci_not, rnd] = R = RealField(prec=prec, sci_not=sci_not, rnd=rnd)
     280        RealField_cache[prec, rnd, print_cached] = R = RealField(prec=prec, rnd=rnd, print_options=printing)
    250281        return R
    251282
    252283cdef class RealField(sage.rings.ring.Field):
     
    262293    details.
    263294    """
    264295
    265     def __init__(self, int prec=53, int sci_not=0, rnd="RNDN"):
     296    def __init__(self, int prec=53, scientific_notation=None, rnd="RNDN", print_options=None, sci_not=None):
     297
     298        if sci_not is not None:
     299            from sage.misc.misc import deprecation
     300            deprecation("The sci_not keyword is deprecated.  Use print_options={'scientific_notation': %r} instead."%sci_not_deprecation[sci_not], 'Sage 4.3.1')
     301            scientific_notation=sci_not_deprecation[sci_not]
     302
    266303        global MY_MPFR_PREC_MAX
     304        if print_options is None:
     305            print_options={}
     306        if 'scientific_notation' in print_options:
     307            if scientific_notation is None:
     308                scientific_notation = print_options['scientific_notation']
     309            else:
     310                print_options['scientific_notation']=scientific_notation
     311        else:
     312            if scientific_notation is not None:
     313                print_options['scientific_notation']=scientific_notation
     314
    267315        cdef RealNumber rn
    268316        if prec < MPFR_PREC_MIN or prec > MY_MPFR_PREC_MAX:
    269317            raise ValueError, "prec (=%s) must be >= %s and <= %s."%(
     
    271319        self.__prec = prec
    272320        if not isinstance(rnd, str):
    273321            raise TypeError, "rnd must be a string"
    274         self.sci_not = sci_not
     322        self.print_options=print_options
    275323        n = _rounding_modes.index(rnd)
    276324        if n == -1:
    277325            raise ValueError, "rnd (=%s) must be one of RNDN, RNDZ, RNDU, or RNDD"%rnd
     
    314362        return s
    315363
    316364    def _latex_(self):
    317         return "\\Bold{R}"
     365        """
     366        The latex representation of self.
     367
     368        EXAMPLE::
     369           
     370            sage: RealField(100)._latex_()
     371            '\\Bold{R}^{}_{100}'
     372            sage: RealField(100,rnd='RNDD')._latex_()
     373            '\\Bold{R}^{-}_{100}'
     374            sage: RealField(100,rnd='RNDU')._latex_()
     375            '\\Bold{R}^{+}_{100}'
     376            sage: RealField(100,rnd='RNDZ')._latex_()
     377            '\\Bold{R}^{0}_{100}'
     378            sage: RR._latex_()
     379            '\\Bold{R}^{}_{53}'
     380        """
     381        rnd_str={'RNDN':'', 'RNDZ':'0', 'RNDU':'+', 'RNDD':'-'}
     382
     383        return "\\Bold{R}^{%s}_{%s}"%(rnd_str[self.rnd_str],self.__prec)
    318384
    319385    def _sage_input_(self, sib, coerce):
    320386        r"""
     
    357423        return v
    358424
    359425    cpdef bint is_exact(self) except -2:
     426        """
     427        Return False, since a real field (representing using finite
     428        precision) is not exact.
     429
     430        EXAMPLE::
     431
     432            sage: RR.is_exact()
     433            False
     434            sage: RealField(100).is_exact()
     435            False
     436        """
    360437        return False
    361438
    362439    def _element_constructor_(self, x, base=10):
     
    388465        """
    389466        Canonical coercion of x to this mpfr real field.
    390467       
    391         The rings that canonically coerce to this mpfr real field are:
    392 
    393         - Any mpfr real field with precision that is as large as this one
     468        The rings that canonically coerce to this MPFR real field are:
     469
     470        - Any MPFR real field with precision that is as large as this one
    394471
    395472        - int, long, integer, and rational rings.
    396473
     
    464541
    465542    def __cmp__(self, other):
    466543        """
     544        Compare two real fields, returning True if they are equivalent
     545        and False if they are not.
     546
    467547        EXAMPLES::
    468548       
    469549            sage: RealField(10) == RealField(11)
     
    478558       
    479559        ::
    480560       
    481             sage: RealField(10,sci_not=True) == RealField(10,sci_not=False)
     561            sage: RealField(10,scientific_notation='always') == RealField(10,scientific_notation='extreme')
    482562            True
    483563            sage: RealField(10) == IntegerRing()
    484564            False
    485565       
    486566        ::
    487567       
    488             sage: RS = RealField(sci_not=True)
     568            sage: RS = RealField(scientific_notation='always')
    489569            sage: RR == RS
    490570            True
    491             sage: RS.scientific_notation(False)
     571            sage: RS.print_options['scientific_notation']='extreme'
    492572            sage: RR == RS
    493573            True
    494574        """
     
    497577        cdef RealField _other
    498578        _other = other  # to access C structure
    499579        if self.__prec == _other.__prec and self.rnd == _other.rnd: \
    500                #and self.sci_not == _other.sci_not:
    501580            return 0
    502581        return 1
    503582
    504583    def __reduce__(self):
    505584        """
    506         EXAMPLES::
    507        
    508             sage: R = RealField(sci_not=1, prec=200, rnd='RNDU')
     585        Return the arguments sufficient for pickling.
     586
     587        EXAMPLES::
     588       
     589            sage: R = RealField(scientific_notation='always', prec=200, rnd='RNDU')
    509590            sage: loads(dumps(R)) == R
    510591            True
    511592        """
    512         return __create__RealField_version0, (self.__prec, self.sci_not, self.rnd_str)
     593        return __create__RealField_version1, (self.__prec, self.rnd_str, self.print_options)
    513594       
    514595    def construction(self):
    515596        """
    516         Returns the functorial construction of self, namely, completion of
    517         the rational numbers with respect to the prime at
    518         `\infty`.
     597        Returns the functorial construction of self, namely,
     598        completion of the rational numbers with respect to the prime
     599        at `\infty`.
    519600       
    520601        Also preserves other information that makes this field unique (e.g.
    521602        precision, rounding, print mode).
     
    531612        from sage.categories.pushout import CompletionFunctor
    532613        return (CompletionFunctor(sage.rings.infinity.Infinity,
    533614                                  self.prec(),
    534                                   {'sci_not': self.scientific_notation(), 'rnd': self.rounding_mode()}),
     615                                  {'rnd': self.rounding_mode(),'print_options': self.print_options}),
    535616               sage.rings.rational_field.QQ)
    536617
    537618    def gen(self, i=0):
     619        """
     620        Return the generators of self.
     621
     622        EXAMPLES::
     623
     624            sage: R=RealField(100)
     625            sage: R.gen(0)
     626            1.0000000000000000000000000000
     627            sage: R.gen(1)
     628            Traceback (most recent call last):
     629            ...
     630            IndexError: self has only one generator
     631        """
    538632        if i == 0:
    539633            return self(1)
    540634        else:
    541             raise IndexError
     635            raise IndexError, "self has only one generator"
    542636
    543637    def complex_field(self):
    544638        """
    545639        Return complex field of the same precision.
     640
     641        EXAMPLES::
     642       
     643            sage: RR.complex_field()
     644            Complex Field with 53 bits of precision
     645            sage: RR.complex_field() is CC
     646            True
     647            sage: RealField(100,rnd='RNDD').complex_field()
     648            Complex Field with 100 bits of precision
     649            sage: RealField(100).complex_field()               
     650            Complex Field with 100 bits of precision
    546651        """
    547652        import sage.rings.complex_field
    548653        return sage.rings.complex_field.ComplexField(self.prec())
    549654
    550655    def algebraic_closure(self):
    551656        """
    552         Returns the algebraic closure of self, ie the complex field with
     657        Returns the algebraic closure of self, i.e., the complex field with
    553658        the same precision.
     659
     660        EXAMPLES::
     661
     662            sage: RR.algebraic_closure()
     663            Complex Field with 53 bits of precision
     664            sage: RR.algebraic_closure() is CC
     665            True
     666            sage: RealField(100,rnd='RNDD').algebraic_closure()
     667            Complex Field with 100 bits of precision
     668            sage: RealField(100).algebraic_closure()               
     669            Complex Field with 100 bits of precision
    554670        """
    555671        return self.complex_field()
    556672
    557673    def ngens(self):
     674        """
     675        Return the number of generators.
     676
     677        EXAMPLES::
     678       
     679            sage: RR.ngens()
     680            1
     681        """
    558682        return 1
    559683
    560684    def gens(self):
     685        """
     686        Return a list of generators.
     687
     688        EXAMPLE::
     689       
     690            sage: RR.gens()
     691            [1.00000000000000]
     692        """
    561693        return [self.gen()]
    562694
    563695    def _is_valid_homomorphism_(self, codomain, im_gens):
     696        """
     697        Return True if the map from self to codomain sending
     698        self(1) to the unique element of im_gens is a valid field
     699        homomorphism. Otherwise, return False.
     700
     701        EXAMPLES::
     702
     703            sage: RR._is_valid_homomorphism_(RDF,[RDF(1)])
     704            True
     705            sage: RR._is_valid_homomorphism_(CDF,[CDF(1)])
     706            True
     707            sage: RR._is_valid_homomorphism_(CDF,[CDF(-1)])
     708            False
     709            sage: R=RealField(100)
     710            sage: RR._is_valid_homomorphism_(R,[R(1)])     
     711            False
     712            sage: RR._is_valid_homomorphism_(CC,[CC(1)])
     713            True
     714            sage: RR._is_valid_homomorphism_(GF(2),GF(2)(1))     
     715            False
     716        """
     717
    564718        try:
    565719            s = codomain.coerce(self(1))
    566720        except TypeError:
     
    603757        return 0
    604758   
    605759    def name(self):
     760        """
     761        Returns the name of self, which encodes the precision and
     762        rounding convention.
     763
     764        EXAMPLES::
     765       
     766            sage: RR.name()
     767            'RealField53_0'
     768            sage: RealField(100,rnd='RNDU').name()
     769            'RealField100_2'
     770        """
    606771        return "RealField%s_%s"%(self.__prec,self.rnd)
    607772   
    608773    def __hash__(self):
     774        """
     775        Returns a hash function of the field, which takes into account
     776        the precision and rounding convention.
     777       
     778        EXAMPLES::
     779       
     780            sage: hash(RealField(100,rnd='RNDU'))
     781            5446556154562330496
     782            sage: hash(RR)                       
     783            -688242835116843476
     784        """
    609785        return hash(self.name())
    610786
    611787    def precision(self):
     788        """
     789        Returns the precision of self.
     790
     791        EXAMPLES::
     792
     793            sage: RR.precision()
     794            53
     795            sage: RealField(20).precision()
     796            20
     797        """
    612798        return self.__prec
    613799
    614     def prec(self):
    615         return self.__prec
     800    prec=precision # an alias
    616801
    617802    def _magma_init_(self, magma):
    618803        r"""
    619804        Return a string representation of self in the Magma language.
     805
     806        .. warning:: This ignores the rounding convention of self.
    620807       
    621808        EXAMPLES::
    622809       
     
    631818
    632819    def to_prec(self, prec):
    633820        """
    634         Returns the real field that is identical to self, except at the
    635         specified precision.
     821        Returns the real field that is identical to self, except that
     822        it has the specified precision.
    636823       
    637824        EXAMPLES::
    638825       
     
    645832        if prec == self.__prec:
    646833            return self
    647834        else:
    648             return RealField_constructor(prec, self.sci_not, _rounding_modes[self.rnd])
     835            return RealField_constructor(prec, rnd=_rounding_modes[self.rnd],
     836                                         print_options=self.print_options)
    649837   
    650838    # int mpfr_const_pi (mpfr_t rop, mp_rnd_t rnd)
    651839    def pi(self):
     
    718906    # int mpfr_const_log2 (mpfr_t rop, mp_rnd_t rnd)
    719907    def log2(self):
    720908        """
    721         Returns log(2) to the precision of this field.
     909        Returns log(2) (i.e., the natural log of 2) to the precision
     910        of this field.
    722911       
    723912        EXAMPLES::
    724913       
     
    740929        Returns a uniformly distributed random number between min and max
    741930        (default -1 to 1).
    742931       
     932        .. warning:: ``distribution`` is ignored---the random number
     933        is from the uniform distribution.
     934
    743935        EXAMPLES::
    744936       
    745937            sage: RealField(100).random_element(-5, 10)
     
    793985
    794986    def factorial(self, int n):
    795987        """
    796         Return the factorial of the integer n as a real number.
     988        Return the factorial of the integer ``n`` as a real number.
     989
     990        EXAMPLES::
     991
     992            sage: RR.factorial(0)
     993            1.00000000000000
     994            sage: RR.factorial(1000000)         
     995            8.26393168833124e5565708
     996            sage: RR.factorial(-1)
     997            Traceback (most recent call last):
     998            ...
     999            ArithmeticError: n must be nonnegative
    7971000        """
    7981001        cdef RealNumber x
    7991002        if n < 0:
     
    8051008        return x
    8061009
    8071010    def rounding_mode(self):
     1011        """
     1012        Return the rounding mode.
     1013
     1014        EXAMPLES::
     1015       
     1016            sage: RR.rounding_mode()
     1017            'RNDN'
     1018            sage: RealField(20,rnd='RNDZ').rounding_mode()
     1019            'RNDZ'
     1020            sage: RealField(20,rnd='RNDU').rounding_mode()
     1021            'RNDU'
     1022            sage: RealField(20,rnd='RNDD').rounding_mode()
     1023            'RNDD'
     1024        """
    8081025        return _rounding_modes[self.rnd]
    8091026
    8101027    def scientific_notation(self, status=None):
    8111028        """
     1029        .. warning:: Deprecated.  See :meth:`printing_options` for
     1030           this functionality.
     1031       
    8121032        Set or return the scientific notation printing flag. If this flag
    8131033        is True then real numbers with this space as parent print using
    8141034        scientific notation.
    8151035       
    8161036        INPUT:
    817        
    818        
     1037           
    8191038        -  ``status`` - (bool -) optional flag
    820         """
     1039
     1040        EXAMPLES::
     1041
     1042            sage: RR.scientific_notation()
     1043            doctest:1172: DeprecationWarning: (After Sage 4.3.1) scientific_notation() is deprecated.  Use self.print_options['scientific_notation']
     1044            True
     1045
     1046        """
     1047        from sage.misc.misc import deprecation
    8211048        if status is None:
    822             return self.sci_not
    823         else:
    824             self.sci_not = status
    825        
     1049            deprecation("scientific_notation() is deprecated.  Use self.print_options['scientific_notation']", 'Sage 4.3.1')
     1050            return self.print_options.get('scientific_notation',_PRINT_OPTIONS['scientific_notation'])!='always'
     1051        else:
     1052            deprecation("scientific_notation() is deprecated.  Use self.print_options['scientific_notation']=value instead", 'Sage 4.3.1')
     1053            if status is True:
     1054                self.print_options['scientific_notation'] = 'always'
     1055            else:
     1056                self.print_options['scientific_notation'] = 'extreme'
     1057               
     1058
     1059
     1060    property print_options:
     1061        """
     1062        Options for printing a real number.
     1063        """
     1064        def __get__(self):
     1065            """
     1066            Get the printing options.
     1067            """
     1068            return self.print_options
     1069        def __set__(self,newval):
     1070            """
     1071            Set the printing options.
     1072            """
     1073            self.print_options=newval
     1074        def __del__(self):
     1075            """
     1076            Reset the printing options to be empty.
     1077            """
     1078            self.print_options={}
     1079
    8261080    def zeta(self, n=2):
    8271081        """
    8281082        Return an `n`-th root of unity in the real field, if one
     
    10641318        """
    10651319        EXAMPLES::
    10661320       
    1067             sage: R = RealField(sci_not=1, prec=200, rnd='RNDU')
     1321            sage: R = RealField(scientific_notation='always', prec=200, rnd='RNDU')
    10681322            sage: b = R('393.39203845902384098234098230948209384028340')
    10691323            sage: loads(dumps(b)) == b
    10701324            True
     
    10811335            sage: loads(dumps(b)) == b
    10821336            True
    10831337        """
    1084         s = self.str(32, no_sci=False, e='@')
     1338        s = self.str(32, scientific_notation='always', e='@')
    10851339        return (__create__RealNumber_version0, (self._parent, s, 32))
    10861340
    10871341    def  __dealloc__(self):
     
    11221376            sage: s1 == RR(gp(s1))
    11231377            True
    11241378        """
    1125         return self.str(10, no_sci=True, truncate=False)
     1379        return self.str(10, scientific_notation='extreme', truncate=False)
    11261380
    11271381    def _sage_input_(self, sib, coerced):
    11281382        r"""
     
    13231577        """
    13241578        return self._parent
    13251579
    1326     def str(self, int base=10, no_sci=None, e=None, int truncate=1, bint skip_zeroes=0):
     1580    def str(self, int base=10, no_sci=None, e=None, truncate=None, skip_zeroes=None,scientific_notation=None):
    13271581        """
    13281582        INPUT:
    13291583       
    13301584       
    13311585        -  ``base`` - base for output
    13321586       
    1333         -  ``no_sci`` - if 2, never print using scientific
    1334            notation; if 1 or True, print using scientific notation only for
    1335            very large or very small numbers; if 0 or False always print with
    1336            scientific notation; if None (the default), print how the parent
    1337            prints.
     1587        - ``scientific_notation`` - (default: None)
     1588
     1589           - 'never' - never print using scientific notation;
     1590
     1591           - 'extreme' - print using scientific notation only for very
     1592             large or very small numbers;
     1593
     1594           - 'always' - always print with scientific notation;
     1595
     1596           - None (default) - print how the parent prints.
    13381597
    13391598        -  ``e`` - symbol used in scientific notation; defaults to 'e' for
    13401599           base=10, and '@' otherwise
     
    13521611            '20.333333333333332'
    13531612            sage: a.str(2)
    13541613            '10100.010101010101010101010101010101010101010101010101'
    1355             sage: a.str(no_sci=False)
     1614            sage: a.str(scientific_notation='always')
    13561615            '2.03333333333333e1'       
    1357             sage: a.str(16, no_sci=False)
     1616            sage: a.str(16, scientific_notation='always')
    13581617            '1.4555555555555@1'
    13591618            sage: b = 2.0^99
    13601619            sage: b.str()
    13611620            '6.33825300114115e29'
    1362             sage: b.str(no_sci=False)
     1621            sage: b.str(scientific_notation='always')
    13631622            '6.33825300114115e29'
    1364             sage: b.str(no_sci=True)
     1623            sage: b.str(scientific_notation='extreme')
    13651624            '6.33825300114115e29'
    13661625            sage: c = 2.0^100
    13671626            sage: c.str()
    13681627            '1.26765060022823e30'
    1369             sage: c.str(no_sci=False)
     1628            sage: c.str(scientific_notation='always')
    13701629            '1.26765060022823e30'
    1371             sage: c.str(no_sci=True)
     1630            sage: c.str(scientific_notation='extreme')
    13721631            '1.26765060022823e30'
    1373             sage: c.str(no_sci=2)
     1632            sage: c.str(scientific_notation='never')
    13741633            '1267650600228230000000000000000.'
    13751634            sage: 0.5^53
    13761635            1.11022302462516e-16
     
    13891648        """
    13901649        if base < 2 or base > 36:
    13911650            raise ValueError, "the base (=%s) must be between 2 and 36"%base
     1651
     1652        if no_sci is not None:
     1653            from sage.misc.misc import deprecation
     1654            deprecated_option = {0: 'always', 1: 'extreme', 2: 'never'}
     1655            deprecation("The no_sci keyword is deprecated.  Use scientific_notation=%r instead."%deprecated_option[no_sci])
     1656            scientific_notation=deprecated_option[no_sci]
     1657        if scientific_notation not in [None, 'always','extreme','never']:
     1658            raise ValueError, "scientific_notation must be one of 'always', 'extreme', or 'never'."
     1659           
    13921660        if mpfr_nan_p(self.value):
    13931661            if base >= 24:
    13941662                return "@NaN@"
     
    14061674            else:
    14071675                e = 'e'
    14081676
     1677        if skip_zeroes is None:
     1678            skip_zeroes = (<RealField>self._parent).print_options.get('skip_zeroes',_PRINT_OPTIONS['skip_zeroes'])
     1679
     1680        if truncate is None:
     1681            truncate = (<RealField>self._parent).print_options.get('truncate',_PRINT_OPTIONS['truncate'])
     1682
    14091683        cdef char *s
    14101684        cdef mp_exp_t exponent
    14111685
     
    14521726        if t[0] == "-":
    14531727            digits = digits - 1
    14541728
    1455         if no_sci is None:
    1456             no_sci = not (<RealField>self._parent).sci_not
    1457 
    1458         if no_sci is True and ( abs(exponent-1) >=6 ):
    1459             no_sci = False
    1460 
    1461         if no_sci==False:
     1729        if scientific_notation is None:
     1730            scientific_notation = (<RealField>self._parent).print_options.get('scientific_notation',_PRINT_OPTIONS['scientific_notation'])
     1731
     1732        if (scientific_notation=='extreme' and ( abs(exponent-1) >=6 )) \
     1733                or scientific_notation=='always':
    14621734            if t[0] == "-":
    14631735                return "-%s.%s%s%s"%(t[1:2], t[2:], e, exponent-1)
    14641736            return "%s.%s%s%s"%(t[0], t[1:], e, exponent-1)
     
    17722044        return x
    17732045   
    17742046    cpdef ModuleElement _neg_(self):
     2047        """
     2048        Return the negative of self.
     2049       
     2050        EXAMPLES::
     2051
     2052            sage: RR(1)._neg_()
     2053            -1.00000000000000
     2054            sage: RR('inf')._neg_()
     2055            -infinity
     2056            sage: RR('nan')._neg_()
     2057            NaN
     2058        """
    17752059        cdef RealNumber x
    17762060        x = self._new()
    17772061        mpfr_neg(x.value, self.value, (<RealField>self._parent).rnd)
    17782062        return x
    17792063
    17802064    def __abs__(self):
     2065        """
     2066        Return absolute value of self.
     2067
     2068        EXAMPLES::
     2069
     2070            sage: RR(-1).__abs__()       
     2071            1.00000000000000
     2072            sage: RR('-inf').__abs__()
     2073            +infinity
     2074            sage: RR('inf').__abs__()
     2075            +infinity
     2076            sage: RR('nan').__abs__()
     2077            NaN
     2078        """
    17812079        return self.abs()
    17822080
    17832081    cdef RealNumber abs(RealNumber self):
     2082        """
     2083        Return the absolute value of self.
     2084
     2085        EXAMPLES::
     2086
     2087            sage: RR('-1').abs()     
     2088            1.00000000000000
     2089            sage: RR('-inf').abs()
     2090            +infinity
     2091            sage: RR('inf').abs()
     2092            +infinity
     2093            sage: RR('nan').abs()
     2094            NaN
     2095        """
    17842096        cdef RealNumber x
    17852097        x = self._new()       
    17862098        mpfr_abs(x.value, self.value, (<RealField>self._parent).rnd)
     
    17882100
    17892101    # Bit shifting
    17902102    def _lshift_(RealNumber self, n):
     2103        """
     2104        Return `self*(2^n)` for an integer ``n``.
     2105
     2106        EXAMPLES::
     2107
     2108            sage: RR(1.0)._lshift_(32)
     2109            4.29496729600000e9
     2110            sage: RR(1.5)._lshift_(2)
     2111            6.00000000000000
     2112        """
    17912113        cdef RealNumber x
    17922114        if n > sys.maxint:
    17932115            raise OverflowError, "n (=%s) must be <= %s"%(n, sys.maxint)
    17942116        x = self._new()
    1795         mpfr_mul_2exp(x.value, self.value, n, (<RealField>self._parent).rnd)
     2117        mpfr_mul_2ui(x.value, self.value, n, (<RealField>self._parent).rnd)
    17962118        return x
    17972119
    17982120    def __lshift__(x, y):
    17992121        """
     2122        Return `self*(2^n)` for an integer ``n``.
     2123
    18002124        EXAMPLES::
    18012125       
    18022126            sage: 1.0 << 32
     
    18142138            raise TypeError, "unsupported operands for <<"           
    18152139
    18162140    def _rshift_(RealNumber self, n):
     2141        """
     2142        Return `self/(2^n)` for an integer ``n``.
     2143       
     2144        EXAMPLES::
     2145
     2146            sage: RR(1.0)._rshift_(32)
     2147            2.32830643653870e-10
     2148            sage: RR(1.5)._rshift_(2) 
     2149            0.375000000000000
     2150        """
    18172151        if n > sys.maxint:
    18182152            raise OverflowError, "n (=%s) must be <= %s"%(n, sys.maxint)
    18192153        cdef RealNumber x
     
    18232157
    18242158    def __rshift__(x, y):
    18252159        """
     2160        Return `self/(2^n)` for an integer ``n``.
     2161       
    18262162        EXAMPLES::
    18272163       
    18282164            sage: 1024.0 >> 7
     
    18772213        """
    18782214        return mpfr_sgn(self.value)
    18792215
    1880     def prec(self):
     2216    def precision(self):
     2217        """
     2218        Return the precision of self.
     2219
     2220        EXAMPLES::
     2221       
     2222            sage: RR(1.0).precision()
     2223            53
     2224            sage: RealField(101)(-1).precision()     
     2225            101
     2226        """
    18812227        return (<RealField>self._parent).__prec
    18822228
     2229    prec = precision # alias
     2230
    18832231    def conjugate(self):
    18842232        """
    18852233        Return the complex conjugate of this real number, which is the
     
    20552403        mpfr_ceil(x.value, self.value)
    20562404        return x.integer_part()
    20572405
    2058     def ceiling(self):
    2059         return self.ceil()
     2406    ceiling = ceil # alias
    20602407
    20612408    def trunc(self):
    20622409        """
     
    20782425
    20792426    def frac(self):
    20802427        """
    2081         frac returns a real number > -1 and < 1. it satisfies the relation: x =
    2082         x.trunc() + x.frac()
     2428        Returns a real number such that `self = self.trunc() +
     2429        self.frac()`.  The return value will also satisfy `-1 < self.frac() < 1`.
    20832430       
    20842431        EXAMPLES::
    20852432       
     
    20892436            0.500000000000000
    20902437            sage: (-2.79).frac()
    20912438            -0.790000000000000
     2439            sage: (-2.79).trunc() + (-2.79).frac()
     2440            -2.79000000000000
    20922441        """
    20932442        cdef RealNumber x
    20942443        x = self._new()
     
    21852534    ###########################################
    21862535
    21872536    def __float__(self):
     2537        """
     2538        Returns a python float approximating self.
     2539
     2540        EXAMPLES::
     2541
     2542            sage: RR(pi).__float__()     
     2543            3.1415926535897931
     2544            sage: type(RR(pi).__float__())
     2545            <type 'float'>
     2546        """
    21882547        return mpfr_get_d(self.value, (<RealField>self._parent).rnd)
    21892548
    21902549    def _rpy_(self):
     
    22042563
    22052564    def __int__(self):
    22062565        """
    2207         Returns integer truncation of this real number.
     2566        Returns the python integer truncation of self.
     2567
     2568        EXAMPLES::
     2569
     2570            sage: RR(pi).__int__()       
     2571            3
     2572            sage: type(RR(pi).__int__()) 
     2573            <type 'int'>
    22082574        """
    22092575        if not mpfr_number_p(self.value):
    22102576            raise ValueError, 'Cannot convert infinity or NaN to Python int'
     
    22152581
    22162582    def __long__(self):
    22172583        """
    2218         Returns long integer truncation of this real number.
     2584        Returns python long integer truncation of this real number.
     2585
     2586        EXAMPLES::
     2587       
     2588            sage: RR(pi).__long__()
     2589            3L
     2590            sage: type(RR(pi).__long__())
     2591            <type 'long'>
    22192592        """
    22202593        if not mpfr_number_p(self.value):
    22212594            raise ValueError, 'Cannot convert infinity or NaN to Python long'
     
    22252598        return z.__long__()
    22262599
    22272600    def __complex__(self):
     2601        """
     2602        Returns a python complex number equal to self.
     2603
     2604        EXAMPLES::
     2605
     2606            sage: RR(pi).__complex__()   
     2607            (3.1415926535897931+0j)
     2608            sage: type(RR(pi).__complex__())
     2609            <type 'complex'>
     2610        """
     2611
    22282612        return complex(float(self))
    22292613
    22302614    def _complex_number_(self):
     2615        """
     2616        Returns a Sage complex number equal to self.
     2617       
     2618        EXAMPLES::
     2619       
     2620            sage: RR(pi)._complex_number_()       
     2621            3.14159265358979
     2622            sage: parent(RR(pi)._complex_number_())
     2623            Complex Field with 53 bits of precision
     2624        """
    22312625        import sage.rings.complex_field
    22322626        return sage.rings.complex_field.ComplexField(self.prec())(self)
    22332627
     
    28943288
    28953289    def is_infinity(self):
    28963290        """
     3291        Return True if self is infinite and False otherwise.
     3292
    28973293        EXAMPLES::
    28983294       
    28993295            sage: a = RR('1.494') / RR(0); a
     
    29063302            True
    29073303            sage: RR(1.5).is_infinity()
    29083304            False
     3305            sage: RR('nan').is_infinity()
     3306            False
    29093307        """
    29103308        return mpfr_inf_p(self.value)
    29113309       
    29123310    def is_unit(self):
     3311        """
     3312        Return True if self is a unit (has a multiplicative inverse)
     3313        and False otherwise.
     3314
     3315        EXAMPLES::
     3316
     3317            sage: RR(1).is_unit()
     3318            True
     3319            sage: RR('0').is_unit()
     3320            False
     3321            sage: RR('-0').is_unit()
     3322            False
     3323            sage: RR('nan').is_unit()
     3324            False
     3325            sage: RR('inf').is_unit()
     3326            False
     3327            sage: RR('-inf').is_unit()
     3328            False
     3329        """
     3330        return mpfr_sgn(self.value) != 0 and not mpfr_inf_p(self.value)
     3331
     3332    def is_real(self):
     3333        """
     3334        Return True if self is real (of course, this always returns
     3335        True for a finite element of a real field).
     3336
     3337        EXAMPLES::
     3338
     3339            sage: RR(1).is_real()
     3340            True
     3341            sage: RR('-100').is_real()
     3342            True
     3343            sage: RR('nan').is_real() # fail until we decide what it should be
     3344            sage: RR('inf').is_real() # fail until we decide what it should be
     3345        """
     3346        return True
     3347
     3348    def __nonzero__(self):
     3349        """
     3350        Returns True if self is nonzero.
     3351
     3352        EXAMPLES::
     3353
     3354            sage: RR(1).__nonzero__()
     3355            True
     3356            sage: RR(0).__nonzero__()
     3357            False
     3358            sage: RR('inf').__nonzero__()
     3359            True
     3360            sage: RR('nan').__nonzero__() # fail until we decide what it should be
     3361        """
    29133362        return mpfr_sgn(self.value) != 0
    29143363
    2915     def is_real(self):
    2916         return True
    2917 
    2918     def __nonzero__(self):
    2919         return mpfr_sgn(self.value) != 0
    2920 
    29213364    def __richcmp__(left, right, int op):
     3365        """
     3366        Return the cython rich comparison operator (see the cython
     3367        documentation for details).
     3368
     3369        EXAMPLES::
     3370           
     3371            sage: RR('-inf')<RR('inf')
     3372            True
     3373            sage: RR('-inf')<RR('-10000')
     3374            True
     3375            sage: RR('100000000')<RR('inf')   
     3376            True
     3377            sage: RR('100000000')>RR('inf')
     3378            False
     3379            sage: RR('100000000')<RR('inf')
     3380            True
     3381            sage: RR('nan')==RR('nan')
     3382            True
     3383            sage: RR('-1000')<RR('1000')
     3384            True
     3385            sage: RR('1')<RR('1').nextabove()
     3386            True
     3387            sage: RR('1')<=RR('1').nextabove()
     3388            True
     3389            sage: RR('1')<=RR('1')           
     3390            True
     3391            sage: RR('1')<RR('1')
     3392            False
     3393            sage: RR('1')>RR('1')
     3394            False
     3395            sage: RR('1')>=RR('1')
     3396            True
     3397            sage: RR('nan')==RR('nan') # Fail until we decide what it should be
     3398        """
    29223399        return (<RingElement>left)._richcmp(right, op)
    29233400
    29243401    cdef int _cmp_c_impl(left, Element right) except -2:
     3402        """
     3403        Returns -1 if exactly one of the numbers is NaN.  Return -1 if
     3404        left is less than right, 0 if left and right are equal, and 1
     3405        if left is greater than right.
     3406
     3407        EXAMPLES::
     3408
     3409            sage: RR('1')<=RR('1')           
     3410            True
     3411            sage: RR('1')<RR('1')
     3412            False
     3413            sage: RR('1')>RR('1')
     3414            False
     3415            sage: RR('1')>=RR('1')
     3416            True
     3417            sage: RR('nan')==R('nan')
     3418            False
     3419            sage: RR('nan')==RR('nan') # fail until we decide what it should be
     3420            sage: RR('inf')==RR('inf')
     3421            True
     3422            sage: RR('inf')==RR('-inf')
     3423            False
     3424        """
    29253425        cdef RealNumber self, x
    29263426        self = left
    29273427        x = right
     
    30503550        return x
    30513551
    30523552    def __pow(self, RealNumber exponent):
     3553        """
     3554        Compute self raised to the power of exponent, rounded in the
     3555        direction specified by the parent of self.
     3556
     3557        EXAMPLES::
     3558
     3559            sage: R = RealField(30)
     3560            sage: a = R('1.23456')
     3561            sage: a.__pow(20.0)
     3562            67.646297
     3563        """
    30533564        cdef RealNumber x
    30543565        x = self._new()
    30553566        _sig_on               
     
    32173728
    32183729    def log1p(self):
    32193730        """
    3220         Returns log of 1 + self
     3731        Returns log base e of 1 + self
    32213732       
    32223733        EXAMPLES::
    32233734       
     
    45365047
    45375048
    45385049# here because this imports the other two real fields
    4539 def create_RealField(prec=53, type="MPFR", rnd="RNDN", sci_not=0):
     5050def create_RealField(prec=53, type="MPFR", rnd="RNDN", scientific_notation=None, print_options={},sci_not=None):
     5051    """
     5052    A generic constructor that returns the appropriate real field.
     5053
     5054    INPUTS:
     5055
     5056    - ``type``
     5057
     5058      - ``MPFR`` - A real field with precision ``prec`` and the
     5059        specified printing options.
     5060      - ``RDF`` - A real field with double precision
     5061      - ``RQDF`` - A real field with quad double precision
     5062      - ``RLF`` - A real lazy field
     5063      - ``Interval`` - A real interval field with ``prec`` precision
     5064        and the specified printing options
     5065    """
    45405066    if type == "RDF":
    45415067        return RDF
    45425068    elif type == "RQDF":
     
    45445070        return RQDF
    45455071    elif type == "Interval":
    45465072        from real_mpfi import RealIntervalField
    4547         return RealIntervalField(prec, sci_not)
     5073        return RealIntervalField(prec=prec, scientific_notation=scientific_notation, print_options=print_options, sci_not=sci_not)
    45485074    elif type == "RLF":
    45495075        from real_lazy import RLF
    45505076        return RLF
    45515077    else:
    4552         return RealField_constructor(prec, sci_not, rnd)
     5078        return RealField_constructor(prec=prec, scientific_notation=scientific_notation, rnd=rnd, print_options=print_options, sci_not=sci_not)
    45535079
    45545080
    45555081def is_RealField(x):
     5082    """
     5083    Returns True if ``x`` is technically of a python real field type.
     5084
     5085    EXAMPLES::
     5086   
     5087        sage: sage.rings.real_mpfr.is_RealField(RR)
     5088        True
     5089        sage: sage.rings.real_mpfr.is_RealField(CC)
     5090        False
     5091    """
    45565092    return PY_TYPE_CHECK(x, RealField)
    45575093
    45585094def is_RealNumber(x):
     
    45745110    """
    45755111    return PY_TYPE_CHECK(x, RealNumber)
    45765112
     5113def __create__RealField_version1(prec, rnd, print_options):
     5114    """
     5115    Return a real field with precision ``prec``, rounding ``rnd``, and
     5116    print options ``print_options``.
     5117
     5118    EXAMPLES::
     5119
     5120        sage: sage.rings.real_mpfr.__create__RealField_version1(50, 'RNDD',{})
     5121        Real Field with 50 bits of precision and rounding RNDD
     5122    """
     5123    return RealField(prec=prec, rnd=rnd, print_options=print_options)
     5124
    45775125def __create__RealField_version0(prec, sci_not, rnd):
    4578     return RealField(prec, sci_not, rnd)
     5126    """
     5127    Return a real field with precision ``prec``, rounding ``rnd``, and
     5128    the specified scientific notation setting.
     5129
     5130    EXAMPLES::
     5131
     5132        sage: sage.rings.real_mpfr.__create__RealField_version1(50, 'RNDD',{})
     5133        Real Field with 50 bits of precision and rounding RNDD
     5134        sage: R=sage.rings.real_mpfr.__create__RealField_version0(50, True, 'RNDD')
     5135        sage: R.print_options
     5136        {'scientific_notation': 'always'}
     5137    """
     5138    print_options={'scientific_notation':sci_not_deprecation[sci_not]}
     5139    return RealField(prec=prec, rnd=rnd, print_options=print_options)
    45795140
    45805141def __create__RealNumber_version0(parent, x, base=10):
     5142    """
     5143    Create a real number.
     5144
     5145    EXAMPLES::
     5146        sage: sage.rings.real_mpfr.__create__RealNumber_version0(RR, 22,base=3)   
     5147        22.0000000000000
     5148    """
    45815149    return RealNumber(parent, x, base=base)
    45825150
    45835151
    45845152cdef inline RealNumber empty_RealNumber(RealField parent):
     5153    """
     5154    Create and return an empty initialized real number.
     5155
     5156    EXAMPLES:
     5157   
     5158    These are indirect tests of this function.
     5159
     5160        sage: from sage.rings.real_mpfr import RRtoRR
     5161        sage: R10 = RealField(10)
     5162        sage: R100 = RealField(100)
     5163        sage: f = RRtoRR(R100, R10)
     5164        sage: a = R100(1.2)
     5165        sage: f(a)
     5166        1.2
     5167        sage: g = f.section()
     5168        sage: g
     5169        Generic map:
     5170          From: Real Field with 10 bits of precision
     5171          To:   Real Field with 100 bits of precision
     5172        sage: g(f(a))
     5173        1.1992187500000000000000000000
     5174        sage: b = R10(2).sqrt()
     5175        sage: f(g(b))
     5176        1.4
     5177        sage: f(g(b)) == b
     5178        True
     5179    """
     5180
    45855181    cdef RealNumber y = <RealNumber>PY_NEW(RealNumber)
    45865182    y._parent = parent
    45875183    mpfr_init2(y.value, parent.__prec)