Ticket #11870: 11870.patch

File 11870.patch, 21.6 KB (added by jdemeyer, 10 years ago)
  • sage/rings/real_lazy.pyx

    # HG changeset patch
    # User Jeroen Demeyer <jdemeyer@cage.ugent.be>
    # Date 1317304173 -7200
    # Node ID c5ad43fd07faec50915b434a8cdeaf399f11894a
    # Parent  bc8b7228ec42de19b26b9a4b5e5cdd705c4d8358
    Implement abs() for lazy fields, fix ciel->ceil
    Also correct formatting of the doctests
    
    diff --git a/sage/rings/real_lazy.pyx b/sage/rings/real_lazy.pyx
    a b  
    66
    77The main purpose of these classes is to provide a place for exact rings (e.g.
    88number fields) to embed for the coercion model (as only one embedding can be
    9 specified in the forward direction.
     9specified in the forward direction).
    1010"""
    1111
    1212#*****************************************************************************
    1313#     Copyright (C) 2008 Robert Bradshaw <robertwb@math.washington.edu>
    1414#
    1515#  Distributed under the terms of the GNU General Public License (GPL)
    16 #
     16#  as published by the Free Software Foundation; either version 2 of
     17#  the License, or (at your option) any later version.
    1718#                  http://www.gnu.org/licenses/
    1819#*****************************************************************************
    1920
     21
    2022import math
    2123
    2224cdef add, sub, mul, div, pow, neg, inv
     
    4648        _QQx = QQ['x']
    4749    return _QQx
    4850
    49 cdef named_unops = [ 'sqrt', 'erf', 'gamma',  
    50                      'floor', 'ciel', 'trunc',
     51cdef named_unops = [ 'sqrt', 'erf', 'gamma', 'abs',
     52                     'floor', 'ceil', 'trunc',
    5153                     'exp', 'log', 'log10', 'log2',
    5254                     'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan',
    5355                     'csc', 'sec', 'cot', 
     
    6466        """
    6567        Simulates a list of methods found on the real/complex rings.
    6668       
    67         EXAMPLES:
     69        EXAMPLES::
     70
    6871            sage: a = CLF.pi() * CLF.I(); a
    6972            3.141592653589794?*I
    7073            sage: CDF(a)
     
    116119        Returns the algebraic closure of self,
    117120        ie, the complex lazy field.
    118121
    119         EXAMPLES:
     122        EXAMPLES::
     123
    120124            sage: RLF.algebraic_closure()
    121125            Complex Lazy Field
    122126
     
    137141   
    138142    It's primary use is to connect the exact rings (such as number fields) to
    139143    fixed precision real numbers. For example, to specify an embedding of a
    140     number field $K$ into $\RR$ one can map into this field and the
     144    number field `K` into `\RR` one can map into this field and the
    141145    coercion will then be able to carry the mapping to real fields of any
    142146    precision.
    143147   
    144     EXAMPLES:
     148    EXAMPLES::
     149
    145150        sage: a = RLF(1/3)
    146151        sage: a
    147152        0.3333333333333334?
     
    158163
    159164    def __init__(self):
    160165        """
    161         EXAMPLES:
     166        EXAMPLES::
     167
    162168            sage: CC.0 + RLF(1/3)
    163169            0.333333333333333 + 1.00000000000000*I
    164170            sage: ComplexField(200).0 + RLF(1/3)
     
    171177        Returns the interval field that represents the same mathematical
    172178        field as self.
    173179       
    174         EXAMPLES:
     180        EXAMPLES::
     181
    175182            sage: RLF.interval_field()
    176183            Real Interval Field with 53 bits of precision
    177184            sage: RLF.interval_field(200)
     
    189196        the completion of the rationals at infinity to infinite
    190197        precision.
    191198       
    192         EXAMPLES:
     199        EXAMPLES::
     200
    193201            sage: c, S = RLF.construction(); S
    194202            Rational Field
    195203            sage: RLF == c(S)
     
    202210               
    203211    def _latex_(self):
    204212        r"""
    205         EXAMPLES:
     213        EXAMPLES::
     214
    206215            sage: latex(RLF)
    207216            \Bold{R}
    208217        """
     
    210219       
    211220    def gen(self, i=0):
    212221        """
    213         EXAMPLES:
     222        EXAMPLES::
     223
    214224            sage: RLF.gen()
    215225            1
    216226        """
     
    221231
    222232    def __repr__(self):
    223233        """
    224         EXAMPLES:
     234        EXAMPLES::
     235
    225236            sage: RealLazyField()
    226237            Real Lazy Field
    227238        """
     
    229240       
    230241    def __hash__(self):
    231242        """
    232         EXAMPLES:
     243        EXAMPLES::
     244
    233245            sage: hash(RLF) % 2^32 == hash(str(RLF)) % 2^32
    234246            True
    235247        """
     
    237249       
    238250    def __reduce__(self):
    239251        """
    240         TESTS:
     252        TESTS::
     253
    241254            sage: RLF == loads(dumps(RLF))
    242255            True
    243256            sage: RLF is loads(dumps(RLF))
     
    252265    """
    253266    Returns the lazy real field.
    254267   
    255     EXAMPLES:
    256     There is only one lazy real field.
     268    EXAMPLES:
     269
     270    There is only one lazy real field::
     271
    257272        sage: RealLazyField() is RealLazyField()
    258273        True
    259274    """
     
    268283   
    269284    For more information, see the documentation of the RLF.
    270285   
    271     EXAMPLES:
     286    EXAMPLES::
     287
    272288        sage: a = CLF(-1).sqrt()
    273289        sage: a
    274290        1*I
     
    297313        Returns the interval field that represents the same mathematical
    298314        field as self.
    299315
    300         EXAMPLES:
     316        EXAMPLES::
     317
    301318            sage: CLF.interval_field()
    302319            Complex Interval Field with 53 bits of precision
    303320            sage: CLF.interval_field(333)
     
    313330           
    314331    def gen(self, i=0):
    315332        """
    316         EXAMPLES:
     333        EXAMPLES::
     334
    317335            sage: CLF.gen()
    318336            1*I
    319337            sage: ComplexField(100)(CLF.gen())
     
    330348        Returns the functorial construction of self, namely,
    331349        algebraic closure of the real lazy field.
    332350       
    333         EXAMPLES:
     351        EXAMPLES::
     352
    334353            sage: c, S = CLF.construction(); S
    335354            Real Lazy Field
    336355            sage: CLF == c(S)
     
    341360               
    342361    def _latex_(self):
    343362        r"""
    344         EXAMPLES:
     363        EXAMPLES::
     364
    345365            sage: latex(CLF)
    346366            \Bold{C}
    347367        """
     
    349369
    350370    def __repr__(self):
    351371        """
    352         EXAMPLES:
     372        EXAMPLES::
     373
    353374            sage: CLF
    354375            Complex Lazy Field
    355376        """
     
    357378
    358379    def __hash__(self):
    359380        """
    360         EXAMPLES:
     381        EXAMPLES::
     382
    361383            sage: hash(CLF) % 2^32 == hash(str(CLF)) % 2^32
    362384            True
    363385        """
     
    365387
    366388    def __reduce__(self):
    367389        """
    368         TESTS:
     390        TESTS::
     391
    369392            sage: CLF == loads(dumps(CLF))
    370393            True
    371394            sage: CLF is loads(dumps(CLF))
     
    380403    """
    381404    Returns the lazy complex field.
    382405   
    383     EXAMPLES:
    384     There is only one lazy complex field.
     406    EXAMPLES:
     407
     408    There is only one lazy complex field::
     409
    385410        sage: ComplexLazyField() is ComplexLazyField()
    386411        True
    387412    """
     
    408433
    409434    cpdef ModuleElement _add_(left, ModuleElement right):
    410435        """
    411         EXAMPLES:
     436        EXAMPLES::
     437
    412438            sage: RLF(5) + RLF(1/2)
    413439            5.5000000000000000?
    414440        """
     
    421447       
    422448    cpdef ModuleElement _sub_(left, ModuleElement right):
    423449        """
    424         EXAMPLES:
     450        EXAMPLES::
     451
    425452            sage: CLF(5)-2
    426453            3
    427454        """
     
    434461       
    435462    cpdef RingElement _mul_(left, RingElement right):
    436463        """
    437         EXAMPLES:
     464        EXAMPLES::
     465
    438466            sage: CLF(10) * RLF(5)
    439467            50
    440468        """
     
    447475       
    448476    cpdef RingElement _div_(left, RingElement right):
    449477        """
    450         EXAMPLES:
     478        EXAMPLES::
     479
    451480            sage: a = RLF(1) / RLF(6); a
    452481            0.1666666666666667?
    453482            sage: Reals(300)(a)
     
    462491
    463492    def __pow__(left, right, dummy):
    464493        """
    465         EXAMPLES:
     494        EXAMPLES::
     495
    466496            sage: a = RLF(2) ^ (1/2); a
    467497            1.414213562373095?
    468498            sage: Reals(300)(a)
     
    481511       
    482512    def __neg__(self):
    483513        """
    484         EXAMPLES:
     514        EXAMPLES::
     515
    485516            sage: -RLF(7)
    486517            -7
    487518        """
     
    489520
    490521    def __invert__(self):
    491522        """
    492         EXAMPLES
     523        EXAMPLES::
     524
    493525          sage: a = ~RLF(6); a
    494526          0.1666666666666667?
    495527          sage: Reals(90)(a)
     
    502534        If things are being wrapped, tries to compare values. That failing, it
    503535        tries to compare intervals, which may return a false negative.
    504536       
    505         EXAMPLES:
     537        EXAMPLES::
     538
    506539            sage: RLF(3) == RLF(9/3)
    507540            True
    508541            sage: RLF(3) == RLF(4)
     
    518551        left, right = self.approx(), other.approx()
    519552        return cmp(left, right)
    520553       
    521        
    522554    def __richcmp__(left, right, int op):
    523555        return (<Element>left)._richcmp(right, op)
    524556
    525557    def __hash__(self):
    526558        """
    527         EXAMPLES:
     559        EXAMPLES::
     560
    528561            sage: a = RLF(3)
    529562            sage: hash(a)
    530563            3
     
    556589        """
    557590        The string representation of self is an interval in which self is contained.
    558591       
    559         EXAMPLES:
     592        EXAMPLES::
     593
    560594            sage: RLF(3)
    561595            3
    562596            sage: RLF(1/3)
     
    568602        """
    569603        Returns self as an element of an interval field.
    570604       
    571         EXAMPLES:
     605        EXAMPLES::
     606
    572607            sage: CLF(1/6).approx()
    573608            0.1666666666666667?
    574609            sage: CLF(1/6).approx().parent()
    575610            Complex Interval Field with 53 bits of precision
     611
     612        When the absolute value is involved, the result might be real::
     613
     614            sage: z = exp(CLF(1 + I/2)); z
     615            2.38551673095914? + 1.303213729686996?*I
     616            sage: r = z.abs(); r
     617            2.71828182845905?
     618            sage: parent(z.approx())
     619            Complex Interval Field with 53 bits of precision
     620            sage: parent(r.approx())
     621            Real Interval Field with 53 bits of precision
    576622        """
    577623        return self.eval(self._parent.interval_field())
    578624   
    579625    def _real_double_(self, R):
    580626        """
    581         EXAMPLES:
     627        EXAMPLES::
     628
    582629            sage: a = RLF(3)
    583630            sage: RDF(a)
    584631            3.0
     
    587634       
    588635    def _complex_double_(self, R):
    589636        """
    590         EXAMPLES:
     637        EXAMPLES::
     638
    591639            sage: a = RLF(5)
    592640            sage: CDF(a)
    593641            5.0
     
    599647       
    600648    def _generic_(self, R):
    601649        """
    602         EXAMPLES:
     650        EXAMPLES::
     651
    603652            sage: a = RLF(2/3)
    604653            sage: RR(a)
    605654            0.666666666666667
     
    612661           
    613662    def __complex__(self):
    614663        """
    615         EXAMPLES:
     664        EXAMPLES::
     665
    616666            sage: complex(CLF(-1)^(1/4))
    617667            (0.707106781186547...+0.707106781186547...j)
    618668        """
     
    644694        """
    645695        Simulates a list of methods found on the real/complex mpfr classes.
    646696       
    647         EXAMPLES:
     697        EXAMPLES::
     698
    648699            sage: a = RLF(3)
    649700            sage: a.sqrt()
    650701            1.732050807568878?
     
    661712   
    662713def make_element(parent, *args):
    663714    """
    664     EXAMPLES:
     715    EXAMPLES::
     716
    665717        sage: a = RLF(pi) + RLF(sqrt(1/2))
    666718        sage: loads(dumps(a)) == a
    667719        True
     
    674726        """
    675727        Returns the depth of self as an expression, which is always 0.
    676728       
    677         EXAMPLES:
     729        EXAMPLES::
     730
    678731            sage: RLF(4).depth()
    679732            0
    680733        """
     
    684737        """
    685738        A lazy element that simply wraps an element of another ring.
    686739       
    687         EXAMPLES:
     740        EXAMPLES::
     741
    688742            sage: from sage.rings.real_lazy import LazyWrapper
    689743            sage: a = LazyWrapper(RLF, 3)
    690744            sage: a._value
     
    697751       
    698752    def __neg__(self):
    699753        """
    700         EXAMPLES:
     754        EXAMPLES::
     755
    701756            sage: from sage.rings.real_lazy import LazyWrapper
    702757            sage: a = LazyWrapper(RLF, 3)
    703758            sage: (-a)._value
     
    707762
    708763    def __invert__(self):
    709764        """
    710         EXAMPLES:
     765        EXAMPLES::
     766
    711767            sage: from sage.rings.real_lazy import LazyWrapper
    712768            sage: a = LazyWrapper(RLF, 23)
    713769            sage: ~a
     
    719775
    720776    def __float__(self):
    721777        """
    722         EXAMPLES:
     778        EXAMPLES::
     779
    723780            sage: from sage.rings.real_lazy import LazyWrapper
    724781            sage: a = LazyWrapper(CLF, 19)
    725782            sage: float(a)
     
    729786       
    730787    def __nonzero__(self):
    731788        """
    732         EXAMPLES:
     789        EXAMPLES::
     790
    733791            sage: from sage.rings.real_lazy import LazyWrapper
    734792            sage: not LazyWrapper(RLF, 1)
    735793            False
     
    743801
    744802    def __hash__(self):
    745803        """
    746         EXAMPLES:
     804        EXAMPLES::
     805
    747806            sage: hash(CLF(-1))
    748807            -2
    749808            sage: hash(RLF(9/4)) == hash(9/4)
     
    755814        """
    756815        Convert self into an element of R.
    757816       
    758         EXAMPLES:
     817        EXAMPLES::
     818
    759819            sage: a = RLF(12)
    760820            sage: a.eval(ZZ)
    761821            12
     
    766826       
    767827    def __reduce__(self):
    768828        """
    769         TESTS:
     829        TESTS::
     830
    770831            sage: a = RLF(2)
    771832            sage: loads(dumps(a)) == a
    772833            True
     
    782843        A lazy element representing a binary (usually arithmetic) operation
    783844        between two other lazy elements.
    784845       
    785         EXAMPLES:
     846        EXAMPLES::
     847
    786848            sage: from sage.rings.real_lazy import LazyBinop
    787849            sage: a = LazyBinop(RLF, 2, 1/3, operator.add)
    788850            sage: a
     
    808870       
    809871        It is equal to the maximum of the right and left depths, plus one.
    810872       
    811         EXAMPLES:
     873        EXAMPLES::
     874
    812875            sage: from sage.rings.real_lazy import LazyBinop
    813876            sage: a = LazyBinop(RLF, 6, 8, operator.mul)
    814877            sage: a.depth()
     
    825888        """
    826889        Convert the operands to elements of R, then perform the operation on them.
    827890       
    828         EXAMPLES:
     891        EXAMPLES::
     892
    829893            sage: from sage.rings.real_lazy import LazyBinop
    830894            sage: a = LazyBinop(RLF, 6, 8, operator.add)
    831895            sage: a.eval(RR)
    832896            14.0000000000000
    833897       
    834         A bit absurd:
     898        A bit absurd::
     899
    835900            sage: a.eval(str)
    836901            '68'
    837902        """
     
    853918   
    854919    def __float__(self):
    855920        """
    856         EXAMPLES:
     921        EXAMPLES::
     922
    857923            sage: from sage.rings.real_lazy import LazyBinop
    858924            sage: a = LazyBinop(RLF, 3, 1/2, operator.sub)
    859925            sage: float(a)
     
    882948
    883949    def __hash__(self):
    884950        """
    885         EXAMPLES:
     951        EXAMPLES::
     952
    886953            sage: from sage.rings.real_lazy import LazyBinop
    887954            sage: a = LazyBinop(RLF, 5, 1/2, operator.sub)
    888955            sage: hash(a)
     
    907974        """
    908975        Represents a unevaluated single function of one variable.
    909976       
    910         EXAMPLES:
     977        EXAMPLES::
     978
    911979            sage: from sage.rings.real_lazy import LazyUnop
    912980            sage: a = LazyUnop(RLF, 3, sqrt); a
    913981            1.732050807568878?
     
    9351003       
    9361004        It is equal to one more than the depth of its operand.
    9371005       
    938         EXAMPLES:
     1006        EXAMPLES::
     1007
    9391008            sage: from sage.rings.real_lazy import LazyUnop
    9401009            sage: a = LazyUnop(RLF, 3, sqrt)
    9411010            sage: a.depth()
     
    9481017
    9491018    cpdef eval(self, R):
    9501019        """
    951         EXAMPLES:
     1020        EXAMPLES::
     1021
    9521022            sage: from sage.rings.real_lazy import LazyUnop
    9531023            sage: a = LazyUnop(RLF, 3, sqrt)
    9541024            sage: a.eval(ZZ)
     
    9661036
    9671037    def __hash__(self):
    9681038        """
    969         EXAMPLES:
     1039        EXAMPLES::
     1040
    9701041            sage: hash(RLF(sin(1))) #random
    9711042            -1524677126
    9721043        """
     
    9741045
    9751046    def __float__(self):
    9761047        """
    977         EXAMPLES:
     1048        EXAMPLES::
     1049
    9781050            sage: from sage.rings.real_lazy import LazyUnop
    9791051            sage: a = LazyUnop(RLF, 3, sqrt)
    9801052            sage: float(a)
     
    10001072        This class is used to represent the many named methods attached to real
    10011073        numbers, and is instantiated by the __getattr__ method of LazyElements.
    10021074
    1003         EXAMPLES:
     1075        EXAMPLES::
     1076
    10041077            sage: from sage.rings.real_lazy import LazyNamedUnop
    10051078            sage: a = LazyNamedUnop(RLF, 1, 'arcsin')
    10061079            sage: RR(a)
     
    10161089
    10171090    cpdef eval(self, R):
    10181091        """
    1019         TESTS:
     1092        TESTS::
     1093
    10201094            sage: from sage.rings.real_lazy import LazyNamedUnop
    10211095            sage: a = LazyNamedUnop(RLF, 4, 'sqrt')
    10221096            sage: RR(a)
     
    10281102            sage: float(a)
    10291103            2.0
    10301104           
    1031         Now for some extra arguments:
     1105        Now for some extra arguments::
     1106
    10321107            sage: a = RLF(100)
    10331108            sage: a.log(10)
    10341109            2
     
    10541129        """
    10551130        Does something reasonable with functions that are not defined on the interval fields.
    10561131       
    1057         TESTS:
     1132        TESTS::
     1133
    10581134            sage: from sage.rings.real_lazy import LazyNamedUnop
    10591135            sage: LazyNamedUnop(RLF, 8, 'sqrt')
    10601136            2.828427124746190?
     
    10721148
    10731149    def __hash__(self):
    10741150        """
    1075         EXAMPLES:
     1151        EXAMPLES::
     1152
    10761153            sage: from sage.rings.real_lazy import LazyNamedUnop
    10771154            sage: a = LazyNamedUnop(RLF, 1, 'sin')
    10781155            sage: hash(a)
     
    10821159       
    10831160    def __float__(self):
    10841161        """
    1085         TESTS:
     1162        TESTS::
     1163
    10861164            sage: from sage.rings.real_lazy import LazyNamedUnop
    10871165            sage: a = LazyNamedUnop(RLF, 1, 'sin')
    10881166            sage: float(a)
     
    10921170       
    10931171    def __call__(self, *args):
    10941172        """
    1095         TESTS:
     1173        TESTS::
     1174
    10961175            sage: a = RLF(32)
    10971176            sage: a.log(2)
    10981177            5
    10991178            sage: float(a.log(2))
    11001179            5.0
    11011180           
    1102         What is going on here in the background is
     1181        What is going on here in the background is ::
     1182
    11031183            sage: from sage.rings.real_lazy import LazyNamedUnop
    11041184            sage: b = LazyNamedUnop(RLF, a, 'log')
    11051185            sage: b(2)
     
    11121192   
    11131193    def __reduce__(self):
    11141194        """
    1115         TESTS:
     1195        TESTS::
     1196
    11161197            sage: from sage.rings.real_lazy import LazyNamedUnop
    11171198            sage: a = LazyNamedUnop(RLF, 1, 'sin')
    11181199            sage: float(loads(dumps(a))) == float(a)
     
    11301211        """
    11311212        This class represents a real or complex constant (such as pi or I).
    11321213       
    1133         TESTS:
     1214        TESTS::
     1215
    11341216            sage: a = RLF.pi(); a
    11351217            3.141592653589794?
    11361218            sage: RealField(300)(a)
     
    11481230
    11491231    cpdef eval(self, R):
    11501232        """
    1151         EXAMPLES:
     1233        EXAMPLES::
     1234
    11521235            sage: from sage.rings.real_lazy import LazyConstant
    11531236            sage: a = LazyConstant(RLF, 'e')
    11541237            sage: RDF(a)
     
    11741257   
    11751258    def __call__(self, *args):
    11761259        """
    1177         TESTS:
     1260        TESTS::
     1261
    11781262            sage: CLF.I()
    11791263            1*I
    11801264            sage: CDF(CLF.I())
     
    11881272
    11891273    def __hash__(self):
    11901274        """
    1191         TESTS:
     1275        TESTS::
     1276
    11921277            sage: from sage.rings.real_lazy import LazyConstant
    11931278            sage: a = LazyConstant(RLF, 'e')
    11941279            sage: hash(a)
     
    11981283       
    11991284    def __float__(self):
    12001285        """
    1201         TESTS:
     1286        TESTS::
     1287
    12021288            sage: from sage.rings.real_lazy import LazyConstant
    12031289            sage: a = LazyConstant(RLF, 'pi')
    12041290            sage: float(a)
     
    12091295
    12101296    def __reduce__(self):
    12111297        """
    1212         TESTS:
     1298        TESTS::
     1299
    12131300            sage: from sage.rings.real_lazy import LazyConstant
    12141301            sage: a = LazyConstant(RLF, 'pi')
    12151302            sage: float(loads(dumps(a))) == float(a)
     
    12311318        This represents an algebraic number, specified by a polynomial over
    12321319        \Q and a real or complex approximation.
    12331320       
    1234         EXAMPLES:
     1321        EXAMPLES::
     1322
    12351323            sage: x = polygen(QQ)
    12361324            sage: from sage.rings.real_lazy import LazyAlgebraic
    12371325            sage: a = LazyAlgebraic(RLF, x^2-2, 1.5)
     
    12581346   
    12591347    cpdef eval(self, R):
    12601348        """
    1261         EXAMPLES:
     1349        EXAMPLES::
     1350
    12621351            sage: from sage.rings.real_lazy import LazyAlgebraic
    12631352            sage: a = LazyAlgebraic(CLF, QQ['x'].cyclotomic_polynomial(7), 0.6+0.8*CC.0)
    12641353            sage: a
     
    13141403
    13151404    def __float__(self):
    13161405        """
    1317         TESTS:
     1406        TESTS::
     1407
    13181408            sage: x = polygen(QQ)
    13191409            sage: from sage.rings.real_lazy import LazyAlgebraic
    13201410            sage: a = LazyAlgebraic(RLF, x^3-10, 1.5)
     
    13251415
    13261416    def __reduce__(self):
    13271417        """
    1328         TESTS:
     1418        TESTS::
     1419
    13291420            sage: from sage.rings.real_lazy import LazyAlgebraic
    13301421            sage: a = LazyAlgebraic(RLF, x^2-2, 1.5)
    13311422            sage: float(loads(dumps(a))) == float(a)
     
    13411432        This morphism coerces elements from anywhere into lazy rings
    13421433        by creating a wrapper element (as fast as possible).
    13431434       
    1344         EXAMPLES:
     1435        EXAMPLES::
     1436
    13451437            sage: from sage.rings.real_lazy import LazyWrapperMorphism
    13461438            sage: f = LazyWrapperMorphism(QQ, RLF)
    13471439            sage: a = f(3); a
     
    13581450       
    13591451    cpdef Element _call_(self, x):
    13601452        """
    1361         EXAMPLES:
     1453        EXAMPLES::
     1454
    13621455            sage: from sage.rings.real_lazy import LazyWrapperMorphism
    13631456            sage: f = LazyWrapperMorphism(QQ, CLF)
    13641457            sage: a = f(1/3); a
     
    13681461            sage: Reals(100)(a)
    13691462            0.33333333333333333333333333333
    13701463           
    1371         Note that it doesn't double-wrap lazy elements:
     1464        Note that it doesn't double-wrap lazy elements::
     1465
    13721466            sage: f = LazyWrapperMorphism(RLF, CLF)
    13731467            sage: x = RLF(20)
    13741468            sage: f(x)