Ticket #1772: 1772.patch

File 1772.patch, 32.1 KB (added by mhansen, 12 years ago)
  • sage/functions/constants.py

    # HG changeset patch
    # User Mike Hansen <mhansen@gmail.com>
    # Date 1200689930 28800
    # Node ID c2bd6094a33ca17bbc337e8092d337de4de8c6ae
    # Parent  85934f3b983c44ca9d0ebcd06d5f81492307aae8
    Fixed #1772 and added documentation to constants.py
    
    diff -r 85934f3b983c -r c2bd6094a33c sage/functions/constants.py
    a b TESTS: 
    156156        ...
    157157        TypeError
    158158        sage: RQDF(golden_ratio)
    159         1.618033988749894848204586834365638117720309179805762862135448620
     159        1.618033988749894848204586834365638117720309179805762862135448623
    160160        sage: RQDF(log2)
    161161        0.693147180559945309417232121458176568075500134360255254120680009
    162162        sage: RQDF(euler_gamma)
    TESTS: 
    172172        sage: RQDF(brun)
    173173        Traceback (most recent call last):
    174174        ...
    175         TypeError: Brun's constant only available up to 41 bits
     175        NotImplementedError: Brun's constant only available up to 41 bits
    176176
    177177
    178178Coercing the sum of a bunch of the constants to many different
    class Constant(Function): 
    263263
    264264    # The maxima one is special:
    265265    def _maxima_(self, session=None):
     266        """
     267        Returns self as a maxima object.
     268
     269        EXAMPLES:
     270            sage: pi._maxima_()
     271            %pi
     272        """
    266273        if session is None:
     274            from sage.calculus.calculus import maxima
    267275            return RingElement._maxima_(self, maxima)
    268276        else:
    269277            return RingElement._maxima_(self, session)
    270278
    271279    def _has_op(self, x):
     280        """
     281        Check whether or not self contains the operation x.  Since
     282        self is a constant, this is always False.
     283
     284        EXAMPLES:
     285            sage: pi._has_op(operator.add)
     286            False
     287        """
    272288        return False
    273289
     290    def number_of_arguments(self):
     291        """
     292        Returns the number of arguments of self.  For constants,
     293        this is just zero.
     294
     295        EXAMPLES:
     296            sage: type(pi)
     297            <class 'sage.functions.constants.Pi'>
     298            sage: pi.number_of_arguments()
     299            0
     300            sage: e.number_of_arguments()
     301            0
     302        """
     303        return 0
     304
    274305    def substitute(self, *args, **kwds):
     306        """
     307        Substitute values into self.  For constants, this just returns
     308        self.
     309
     310        EXAMPLES:
     311            sage: pi.substitute(x=3)
     312            pi
     313            sage: pi.substitute(3)
     314            pi
     315            sage: pi.substitute(4, x=4)
     316            pi
     317
     318        """
    275319        return self
    276320
    277321    def _recursive_sub(self, kwds):
    278         return self
     322        """
     323        Recursively substitute values into self.  For constants, this just
     324        returns self.
    279325
    280     def _recursive_sub(self, kwds):
     326        EXAMPLES:
     327            sage: pi._recursive_sub({x:3})
     328            pi
     329        """
    281330        return self
    282331
    283332    def _recursive_sub_over_ring(self, kwds, ring):
     333        """
     334        Recursively substitute values into self over a ring.
     335        For constants, this just returns ring(self).
     336
     337        EXAMPLES:
     338            sage: pi._recursive_sub_over_ring({x:3}, RDF)
     339            3.14159265359
     340        """
    284341        return ring(self)
    285342
    286343    def variables(self):
     344        """
     345        Return a list of the variables of self.  For constants, this
     346        is the empty list.
     347
     348        EXAMPLES:
     349            sage: pi.variables()
     350            []
     351            sage: e.variables()
     352            []
     353        """
    287354        return []
    288355
    289356    def _ser(self):
     357        """
     358        Returns self as an element of SymbolicRing.
     359
     360        EXAMPLES:
     361            sage: s = pi._ser(); s
     362            pi
     363            sage: type(s)
     364            <class 'sage.calculus.calculus.SymbolicConstant'>
     365            sage: s.parent()
     366            Symbolic Ring
     367        """
    290368        try:
    291369            return self.__ser
    292370        except AttributeError:
    293371            self.__ser = sage.calculus.calculus.SR._coerce_impl(self)
    294372            return self.__ser
     373       
     374    def __abs__(self):
     375        """
     376        Returns the absolute value of self.
     377       
     378        EXAMPLES:
     379           sage: abs(pi)
     380           pi
     381        """
     382        if self.str()[0] != '-':
     383            return self
     384        return -self
    295385
    296386    def _neg_(self):
     387        """
     388        Returns the negation of self.
     389
     390        EXAMPLES:
     391            sage: -pi
     392            -1*pi
     393            sage: -e
     394            -1*e
     395        """
    297396        return -Integer(1)*self
    298397
    299     def __call__(self, x):
     398    def __call__(self, *args, **kwargs):
     399        """
     400        Call self as a function.  Since self is a constant function,
     401        this just returns self.
     402
     403        EXAMPLES:
     404            sage: pi(2,3,4)
     405            pi
     406            sage: pi(pi)
     407            pi
     408        """
    300409        return self
    301410
    302411    def floor(self):
     412        """
     413        Returns the floor of self.
     414       
     415        EXAMPLES:
     416            sage: pi.floor()
     417            3
     418            sage: e.floor()
     419            2
     420            sage: golden_ratio.floor()
     421            1
     422            sage: log2.floor()
     423            0
     424        """
    303425        return Integer(int(float(self)))
    304426
    305427    def _latex_(self):
     428        r"""
     429        Return the \LaTeX representation of self.
     430
     431        EXAMPLES:
     432            sage: catalan._latex_()
     433            '\\text{catalan}'
     434        """
    306435        return '\\text{%s}'%self
    307436   
    308437    def _complex_mpfr_field_(self, R):
     438        """
     439        EXAMPLES:
     440            sage: pi._complex_mpfr_field_(ComplexField(53))
     441            3.14159265358979
     442            sage: pi._complex_mpfr_field_(ComplexField(200))
     443            3.1415926535897932384626433832795028841971693993751058209749
     444        """
    309445        return R(self._mpfr_(R._real_field()))
    310446
    311447    def _real_double_(self, R):
     448        """
     449        EXAMPLES:
     450           sage: pi._real_double_(RDF)
     451           3.14159265359
     452        """
    312453        return R(float(self))
    313454
    314455    def _complex_double_(self, R):
     456        """
     457        EXAMPLES:
     458            sage: pi._complex_double_(CDF)
     459            3.14159265359
     460        """
    315461        return R(float(self))
    316462   
    317463    # The following adds formal arithmetic support for generic constant
    class Constant(Function): 
    395541        return False
    396542
    397543    def __lt__(self, right):
     544        """
     545        EXAMPLES:
     546            sage: pi < 3
     547            pi < 3
     548            sage: type(pi<3)
     549            <class 'sage.calculus.equations.SymbolicEquation'>
     550            sage: bool(pi<3)
     551            False
     552        """
    398553        return self._ser().__lt__(right)
    399554
    400555    def __le__(self, right):
     556        """
     557        EXAMPLES:
     558            sage: pi <= 3
     559            pi <= 3
     560            sage: type(pi<=3)
     561            <class 'sage.calculus.equations.SymbolicEquation'>
     562            sage: bool(pi<=3)
     563            False
     564        """
    401565        return self._ser().__le__(right)
    402566
    403567    def __eq__(self, right):
    class Constant(Function): 
    411575        return self._ser().__eq__(right)
    412576
    413577    def __ne__(self, right):
     578        """
     579        EXAMPLES:
     580            sage: type(pi != 3)
     581            <class 'sage.calculus.equations.SymbolicEquation'>
     582            sage: bool(pi != 3)
     583            True
     584        """
    414585        return self._ser().__ne__(right)       
    415586
    416587    def __ge__(self, right):
     588        """
     589        EXAMPLES:
     590            sage: type(pi>=3)
     591            <class 'sage.calculus.equations.SymbolicEquation'>
     592            sage: bool(pi>=3)
     593            True
     594        """
    417595        return self._ser().__ge__(right)       
    418596
    419597    def __gt__(self, right):
     598        """
     599        EXAMPLES:
     600            sage: type(pi>3)
     601            <class 'sage.calculus.equations.SymbolicEquation'>
     602            sage: bool(pi>3)
     603            True
     604        """
    420605        return self._ser().__gt__(right)       
    421606
    422607
    class Pi(Constant): 
    465650        3.141592653589793
    466651    """
    467652    def __init__(self):
     653        """
     654        EXAMPLES:
     655            sage: bool(pi == loads(dumps(pi)))
     656            True
     657        """
    468658        Constant.__init__(self,
    469659            {'axiom':'%pi',
    470660             'maxima':'%pi','gp':'Pi','kash':'PI','mathematica':'Pi',
    471661             'matlab':'pi','maple':'Pi','octave':'pi','pari':'Pi'})
    472662       
    473663    def _repr_(self, simplify=True):
     664        """
     665        EXAMPLES:
     666            sage: repr(pi)
     667            'pi'
     668        """
    474669        return "pi"
    475670
    476671    def _latex_(self):
     672        """
     673        EXAMPLES:
     674            sage: pi._latex_()
     675            '\\pi'
     676            sage: latex(pi)
     677            \pi
     678        """
    477679        return "\\pi"
    478680
    479681    def _mathml_(self):
     682        """
     683        EXAMPLES:
     684            sage: pi._mathml_()
     685            '<mi>&pi;</mi>'
     686            sage: mathml(pi)
     687            <mi>&pi;</mi>
     688        """
    480689        return "<mi>&pi;</mi>"
    481690
    482691    def __float__(self):
     692        """
     693        EXAMPLES:
     694            sage: float(pi)
     695            3.1415926535897931
     696        """
    483697        return math.pi
    484698
    485699    def _mpfr_(self, R):
     700        """
     701        EXAMPLES:
     702            sage: pi._mpfr_(RealField(100))
     703            3.1415926535897932384626433833
     704        """
    486705        return R.pi()
    487706
    488707    def _real_double_(self, R):
     708        """
     709        EXAMPLES:
     710            sage: pi._real_double_(RDF)
     711            3.14159265359
     712         """
    489713        return R.pi()
    490714
    491715    def _real_rqdf_(self, R):
     716        """
     717        EXAMPLES:
     718            sage: pi._real_rqdf_(RQDF)
     719            3.141592653589793238462643383279502884197169399375105820974944590
     720        """
    492721        return R.pi()
    493722   
    494     def __abs__(self):
    495         if self.str()[0] != '-':
    496             return self
    497         return -self
    498723
    499724    def floor(self):
     725        """
     726        Returns the floor of self.
     727       
     728        EXAMPLES:
     729            sage: pi.floor()
     730            3
     731        """
    500732        return Integer(3)
    501733
    502734    # This just gives a string in singular anyways, and it's
    class I_class(Constant): 
    542774        1.00000000000000e8*I
    543775    """
    544776    def __init__(self):
     777        """
     778        EXAMPLES:
     779            sage: bool(I == loads(dumps(I)))
     780            True
     781        """
    545782        Constant.__init__(self,
    546783            {'axiom':'%i',
    547784             'maxima':'%i','gp':'I','mathematica':'I',
    548785             'matlab':'i','maple':'I','octave':'i','pari':'I'})
    549786       
    550787    def _repr_(self, simplify=True):
     788        """
     789        EXAMPLES:
     790            sage: repr(I)
     791            'I'
     792        """
    551793        return "I"
    552794
    553795    def _latex_(self):
     796        """
     797        EXAMPLES:
     798            sage: I._latex_()
     799            'i'
     800            sage: latex(I)
     801            i
     802        """
    554803        return "i"
    555804       
    556805    def minpoly(self, bits=None, degree=None, epsilon=0):
     806        """
     807        EXAMPLES:
     808            sage: I.minpoly()
     809            x^2 + 1
     810        """
    557811        return QQ['x'].gen(0)**2 + 1       
    558812
    559813    def _mathml_(self):
     814        """
     815        EXAMPLES:
     816            sage: I._mathml_()
     817            '<mi>&i;</mi>'
     818            sage: mathml(I)
     819            <mi>&i;</mi>
     820        """
    560821        return "<mi>&i;</mi>"
    561822
    562823    def __float__(self):
     824        """
     825        EXAMPLES:
     826            sage: float(I)
     827            Traceback (most recent call last):
     828            ...
     829            TypeError
     830        """
    563831        raise TypeError
    564832
    565833    def _mpfr_(self, R):
     834        """
     835        EXAMPLES:
     836            sage: I._mpfr_(RealField(53))
     837            Traceback (most recent call last):
     838            ...
     839            TypeError
     840        """
    566841        raise TypeError
    567842
    568843    def _real_rqdf_(self, R):
     844        """
     845        EXAMPLES:
     846            sage: I._real_rqdf_(RQDF)
     847            Traceback (most recent call last):
     848            ...
     849            TypeError
     850        """
    569851        raise TypeError
    570852
    571853    def _complex_mpfr_field_(self, R):
     854        """
     855        EXAMPLES:
     856            sage: I._complex_mpfr_field_(ComplexField(53))
     857            1.00000000000000*I
     858        """
    572859        return R.gen()
    573860
    574861    def _complex_double_(self, C):
     862        """
     863        EXAMPLES:
     864            sage: I._complex_double_(CDF)
     865            1.0*I
     866        """
    575867        return C.gen()
    576868
    577869    def __complex__(self):
     870        """
     871        EXAMPLES:
     872            sage: complex(I)
     873            1j
     874        """
    578875        return python_complex_i
    579876
    580877    def _real_double_(self, R):
     878        """
     879        EXAMPLES:
     880            sage: I._mpfr_(RealField(53))
     881            Traceback (most recent call last):
     882            ...
     883            TypeError
     884        """
    581885        raise TypeError       
    582886
    583887    def _algebraic_(self, field):
     888        """
     889        EXAMPLES:
     890            sage: QQbar(I)
     891            1*I
     892        """
    584893        import sage.rings.qqbar
    585894        return field(sage.rings.qqbar.QQbar_I)
    586895
    587896    def __abs__(self):
     897        """
     898        EXAMPLES:
     899            sage: abs(I)
     900            1
     901            sage: I.__abs__()
     902            1
     903        """
    588904        return Integer(1)
    589905
    590906    def floor(self):
     907        """
     908        EXAMPLES:
     909            sage: I.floor()
     910            Traceback (most recent call last):
     911            ...
     912            TypeError
     913        """
    591914        raise TypeError
    592915
    593916I = I_class()
    class E(Constant): 
    616939        2.7182818284590451
    617940    """
    618941    def __init__(self):
     942        """
     943        EXAMPLES:
     944            sage: bool( e == loads(dumps(e)) )
     945            True
     946        """
    619947        Constant.__init__(self,
    620948            {'axiom':'%e',
    621949             'maxima':'%e',
    class E(Constant): 
    627955             'octave':'e'})
    628956   
    629957    def _repr_(self, simplify=True):
     958        """
     959        EXAMPLES:
     960            sage: repr(e)
     961            'e'
     962            sage: e._repr_()
     963            'e'
     964        """
    630965        return 'e'
    631966
    632967    def _latex_(self):
     968        """
     969        EXAMPLES:
     970            sage: e._latex_()
     971            'e'
     972            sage: latex(e)
     973            e
     974        """
    633975        return 'e'
    634976   
    635977    def __float__(self):
     978        """
     979        EXAMPLES:
     980            sage: float(e)
     981            2.7182818284590451
     982            sage: e.__float__()
     983            2.7182818284590451
     984        """
    636985        return math.e
    637986
    638987    def _mpfr_(self, R):
     988        """
     989        EXAMPLES:
     990            sage: e._mpfr_(RealField(100))
     991            2.7182818284590452353602874714
     992        """
    639993        return R(1).exp()
    640994
    641995    def floor(self):
     996        """
     997        Returns the floor of self.
     998       
     999        EXAMPLES:
     1000            sage: e.floor()
     1001            2
     1002        """
    6421003        return Integer(2)
    6431004
    6441005    def _real_double_(self, R):
     1006        """
     1007        EXAMPLES:
     1008            sage: e._real_double_(RDF)
     1009            2.71828182846
     1010        """
    6451011        return R(1).exp()
    6461012
    6471013    def _real_rqdf_(self, R):
    class NotANumber(Constant): 
    6671033    Not a Number
    6681034    """
    6691035    def __init__(self):
     1036        """
     1037        EXAMPLES:
     1038            sage: loads(dumps(NaN))
     1039            NaN
     1040        """
    6701041        Constant.__init__(self,
    6711042            {'matlab':'NaN'})
    6721043   
    6731044    def _repr_(self, simplify=True):
     1045        """
     1046        EXAMPLES:
     1047            sage: repr(NaN)
     1048            'NaN'
     1049            sage: NaN._repr_()
     1050            'NaN'
     1051        """
    6741052        return 'NaN'
    6751053 
    6761054    def _mpfr_(self,R):
     1055        """
     1056        EXAMPLES:
     1057            sage: NaN._mpfr_(RealField(53))
     1058            NaN
     1059            sage: type(_)
     1060            <type 'sage.rings.real_mpfr.RealNumber'>
     1061        """
    6771062        return R('NaN') #??? nan in mpfr: void mpfr_set_nan (mpfr_t x)
    6781063
    6791064    def _real_double_(self, R):
    680         return R.nan()
     1065        """
     1066        EXAMPLES:
     1067            sage: RDF(NaN)
     1068            nan
     1069        """
     1070        return R.NaN()
    6811071
    6821072    def _real_rqdf_(self, R):
    6831073        """
    6841074        EXAMPLES:
    685             sage: RQDF (NaN)
     1075            sage: RQDF(NaN)
    6861076            'NaN'
    6871077        """
    6881078        return R.NaN()
    class GoldenRatio(Constant): 
    7081098        3.2360679774997898
    7091099    """
    7101100    def __init__(self):
     1101        """
     1102        EXAMPLES:
     1103            sage: loads(dumps(golden_ratio))
     1104            golden_ratio
     1105        """
    7111106        Constant.__init__(self,{'mathematica':'N[(1+Sqrt[5])/2]','gp':'(1+sqrt(5))/2',
    7121107                                'maple':'(1+sqrt(5))/2','maxima':'(1+sqrt(5))/2',
    7131108                                'pari':'(1+sqrt(5))/2','octave':'(1+sqrt(5))/2',
    7141109                                'kash':'(1+Sqrt(5))/2'})
    7151110    def _repr_(self, simplify=True):
     1111        """
     1112        EXAMPLES:
     1113            sage: repr(golden_ratio)
     1114            'golden_ratio'
     1115            sage: golden_ratio._repr_()
     1116            'golden_ratio'
     1117        """
    7161118        return 'golden_ratio'
    7171119
    718     def _latex_(self):
     1120    def _latex_(self):
     1121        """
     1122        EXAMPLES:
     1123            sage: latex(golden_ratio)
     1124            \phi
     1125            sage: golden_ratio._latex_()
     1126            '\\phi'
     1127        """
    7191128        return '\\phi'
    7201129
    7211130    def minpoly(self, bits=None, degree=None, epsilon=0):
     1131        """
     1132        EXAMPLES:
     1133            sage: golden_ratio.minpoly()
     1134            x^2 - x - 1
     1135        """
    7221136        x = QQ['x'].gen(0)
    7231137        return x**2 - x - 1       
    7241138
    7251139    def __float__(self):
     1140        """
     1141        EXAMPLES:
     1142            sage: float(golden_ratio)
     1143            1.6180339887498949
     1144            sage: golden_ratio.__float__()
     1145            1.6180339887498949
     1146        """
    7261147        return float(0.5)*(float(1.0)+math.sqrt(float(5.0)))
    7271148
    7281149    def _real_double_(self, R):
    class GoldenRatio(Constant): 
    7341155        return R('1.61803398874989484820458')
    7351156
    7361157    def _real_rqdf_(self, R):
    737         return R('1.61803398874989484820458683436563811772030917980576286213544862')
     1158        """
     1159        EXAMPLES:
     1160            sage: golden_ratio._real_rqdf_(RQDF)
     1161            1.618033988749894848204586834365638117720309179805762862135448623
     1162            sage: RQDF(golden_ratio)
     1163            1.618033988749894848204586834365638117720309179805762862135448623
     1164        """
     1165        return (R(1)+R(5).sqrt())/R(2)
    7381166   
    739     def _mpfr_(self,R):  #is this OK for _mpfr_ ?
    740         return (R(1)+R(5).sqrt())*R(0.5)
     1167    def _mpfr_(self,R):
     1168        """
     1169        EXAMPLES:
     1170            sage: golden_ratio._mpfr_(RealField(100))
     1171            1.6180339887498948482045868344
     1172            sage: RealField(100)(golden_ratio)
     1173            1.6180339887498948482045868344
     1174        """
     1175        return (R(1)+R(5).sqrt())/R(2)
    7411176
    7421177    def _algebraic_(self, field):
     1178        """
     1179        EXAMPLES:
     1180            sage: golden_ratio._algebraic_(QQbar)
     1181            [1.6180339887498946 .. 1.6180339887498950]
     1182            sage: QQbar(golden_ratio)
     1183            [1.6180339887498946 .. 1.6180339887498950]
     1184        """
    7431185        import sage.rings.qqbar
    7441186        return field(sage.rings.qqbar.get_AA_golden_ratio())
    7451187
    class Log2(Constant): 
    7731215        0.69314718055994530941723212145817656807   # 64-bit
    7741216    """
    7751217    def __init__(self):
    776         # TODO: Here you should put a string that *symbolically* evaluates
    777         # to sqrt(2) in each system, if possible.  E.g., in
    778         # mathematica I think Sqrt[2] means sqrt(2) algebraically.
     1218        """
     1219        EXAMPLES:
     1220            sage: loads(dumps(log2))
     1221            log2
     1222        """
    7791223        Constant.__init__(self,{'mathematica':'N[Log[2]]','kash':'Log(2)',
    7801224                                'maple':'log(2)','maxima':'log(2)','gp':'log(2)',
    7811225                                'pari':'log(2)','octave':'log(2)'})
    7821226
    7831227    def _repr_(self, simplify=True):
     1228        """
     1229        EXAMPLES:
     1230            sage: repr(log2)
     1231            'log2'
     1232            sage: log2._repr_()
     1233            'log2'
     1234        """
    7841235        return 'log2'
    7851236
    7861237    def _latex_(self):
     1238        """
     1239        EXAMPLES:
     1240            sage: log2._latex_()
     1241            '\\log(2)'
     1242            sage: latex(log2)
     1243            \log(2)
     1244        """
    7871245        return '\\log(2)'
    7881246
    7891247    def __float__(self):
     1248        """
     1249        EXAMPLES:
     1250            sage: float(log2)
     1251            0.69314718055994529
     1252            sage: log2.__float__()
     1253            0.69314718055994529
     1254        """
    7901255        return math.log(2)
    7911256
    7921257    def _real_double_(self, R):
    class Log2(Constant): 
    8061271        return R.log2()
    8071272   
    8081273    def _mpfr_(self,R):
     1274        """
     1275        EXAMPLES:
     1276            sage: RealField(100)(log2)
     1277            0.69314718055994530941723212146
     1278            sage: log2._mpfr_(RealField(100))
     1279            0.69314718055994530941723212146
     1280        """
    8091281        return R.log2()
    8101282
    8111283    def floor(self):
     1284        """
     1285        Returns the floor of self.
     1286       
     1287        EXAMPLES:
     1288            sage: log2.floor()
     1289            0
     1290        """
    8121291        return Integer(0)
    8131292
    8141293log2 = Log2()
    class EulerGamma(Constant): 
    8311310        1.1544313298030657212130241801648048620843186718798471976115
    8321311    """
    8331312    def __init__(self):
     1313        """
     1314        EXAMPLES:
     1315            sage: loads(dumps(euler_gamma))
     1316            euler_gamma
     1317        """
    8341318        Constant.__init__(self,
    8351319            {'kash':'EulerGamma(R)','maple':'gamma',
    8361320             'mathematica':'EulerGamma','pari':'Euler',
    8371321             'maxima':'%gamma', 'maxima':'euler_gamma'})   
    8381322
    8391323    def _repr_(self, simplify=True):
     1324        """
     1325        EXAMPLES:
     1326            sage: repr(euler_gamma)
     1327            'euler_gamma'
     1328            sage: euler_gamma._repr_()
     1329            'euler_gamma'
     1330        """
    8401331        return 'euler_gamma'
    8411332
    8421333    def _latex_(self):
     1334        """
     1335        EXAMPLES:
     1336            sage: euler_gamma._latex_()
     1337            '\\gamma'
     1338            sage: latex(euler_gamma)
     1339            \gamma
     1340        """
    8431341        return '\\gamma'
    8441342
    8451343    def _mpfr_(self,R):
     1344        """
     1345        EXAMPLES:
     1346            sage: RealField(100)(euler_gamma)
     1347            0.57721566490153286060651209008
     1348            sage: euler_gamma._mpfr_(RealField(100))
     1349            0.57721566490153286060651209008
     1350        """
    8461351        return R.euler_constant()
    8471352
    8481353    def _real_double_(self, R):
    class EulerGamma(Constant): 
    8541359        return R.euler_constant()
    8551360
    8561361    def _real_rqdf_(self, R):
     1362        """
     1363        EXAMPLES:
     1364            sage: RQDF(euler_gamma)
     1365            0.577215664901532860606512090082402431042159335939923598805767234
     1366            sage: euler_gamma._real_rqdf_(RQDF)
     1367            0.577215664901532860606512090082402431042159335939923598805767234
     1368        """
    8571369        return R('0.577215664901532860606512090082402431042159335939923598805767235')
    8581370   
    8591371    def floor(self):
     1372        """
     1373        Return the floor of self.
     1374
     1375        EXAMPLES:
     1376            sage: euler_gamma.floor()
     1377            0
     1378        """
    8601379        return Integer(0)
    8611380
    8621381euler_gamma = EulerGamma()
    class Catalan(Constant): 
    8711390        merten + catalan^2
    8721391    """
    8731392    def __init__(self):
     1393        """
     1394        EXAMPLES:
     1395            sage: loads(dumps(catalan))
     1396            catalan
     1397        """
    8741398        Constant.__init__(self,
    8751399             {'mathematica':'Catalan','kash':'Catalan(R)', #kash: R is default prec
    8761400              'maple':'Catalan', 'maxima':'catalan'})
    8771401                                         
    8781402    def _repr_(self, simplify=True):
     1403        """
     1404        EXAMPLES:
     1405            sage: repr(catalan)
     1406            'catalan'
     1407            sage: catalan._repr_(catalan)
     1408            'catalan'
     1409        """
    8791410        return 'catalan'
    8801411
    881     def _mpfr_(self, R): 
     1412    def _mpfr_(self, R):
     1413        """
     1414        EXAMPLES:
     1415            sage: RealField(100)(catalan)
     1416            0.91596559417721901505460351493
     1417            sage: catalan._mpfr_(RealField(100))
     1418            0.91596559417721901505460351493
     1419        """
    8821420        return R.catalan_constant()
    8831421
    8841422    def _real_double_(self, R):
    class Catalan(Constant): 
    8911429        return R('0.91596559417721901505460351493252')
    8921430
    8931431    def _real_rqdf_(self, R):
     1432        """
     1433        EXAMPLES:
     1434            sage: RQDF(catalan)
     1435            0.915965594177219015054603514932384110774149374281672134266498119
     1436        """
    8941437        return R('0.915965594177219015054603514932384110774149374281672134266498120')
    8951438   
    8961439    def __float__(self):
    class Catalan(Constant): 
    9021445        return 0.91596559417721901505460351493252
    9031446
    9041447    def floor(self):
     1448        """
     1449        Return the floor of self.
     1450
     1451        EXAMPLES:
     1452            sage: catalan.floor()
     1453            0
     1454        """
    9051455        return Integer(0)
    9061456
    9071457catalan = Catalan()
    class Khinchin(Constant): 
    9231473        2.6854520010653064453097148354817956938203822939944629530511523455572188595371520028011411749318476979951534659052880900828976777164109630517925334832596683818523154213321194996260393285220448194096181                # 64-bit
    9241474    """
    9251475    def __init__(self):
     1476        """
     1477        EXAMPLES:
     1478            sage: loads(dumps(khinchin))
     1479            khinchin
     1480        """
    9261481        Constant.__init__(self,
    9271482             {'maxima':'khinchin', 'mathematica':'Khinchin'}) #Khinchin is only implemented in Mathematica
    9281483       
    class Khinchin(Constant): 
    9311486        self.__bits = len(self.__value)*3-1   # underestimate
    9321487
    9331488    def _repr_(self, simplify=True):
     1489        """
     1490        EXAMPLES:
     1491            sage: repr(khinchin)
     1492            'khinchin'
     1493            sage: khinchin._repr_()
     1494            'khinchin'
     1495        """
    9341496        return 'khinchin'
    9351497
    9361498    def _mpfr_(self, R):
     1499        """
     1500        EXAMPLES:
     1501            sage: RealField(100)(khinchin)
     1502            2.6854520010653064453097148355
     1503            sage: RealField(20000)(khinchin)
     1504            Traceback (most recent call last):
     1505            ...
     1506            NotImplementedError: Khinchin's constant only available up to 3005 bits
     1507        """
    9371508        if R.precision() <= self.__bits:
    9381509            return R(self.__value)
    9391510        raise NotImplementedError, "Khinchin's constant only available up to %s bits"%self.__bits
    class Khinchin(Constant): 
    9471518        return R('2.685452001065306445309714835481795693820')
    9481519
    9491520    def _real_rqdf_(self, R):
     1521        """
     1522        EXAMPLES:
     1523            sage: RQDF(khinchin)
     1524            2.685452001065306445309714835481795693820382293994462953051152345
     1525        """
    9501526        return R(self.__value[:65])
    9511527   
    952     def __float__(self):
    953         return 2.685452001065306445309714835481795693820
     1528    def __float__(self):
     1529        """
     1530        EXAMPLES:
     1531            sage: float(khinchin)
     1532            2.6854520010653062
     1533        """
     1534        return float(self.__value)
    9541535
    9551536    def floor(self):
     1537        """
     1538        Returns the floor of self.
     1539       
     1540        EXAMPLES:
     1541            sage: khinchin.floor()
     1542            2
     1543        """
    9561544        return Integer(2)
    9571545
    9581546khinchin  = Khinchin()
    class TwinPrime(Constant): 
    9721560        0.66016181584686957392781211001455577843262336028473341331945
    9731561    """
    9741562    def __init__(self):
     1563        """
     1564        EXAMPLES:
     1565            sage: loads(dumps(twinprime))
     1566            twinprime
     1567        """
    9751568        Constant.__init__(self,{'maxima':'twinprime'}) #Twin prime is not implemented in any other algebra systems.
    9761569       
    9771570        #digits come from http://www.gn-50uma.de/alula/essays/Moree/Moree-details.en.shtml
    class TwinPrime(Constant): 
    9811574        self.__bits = len(self.__value)*3-1   # underestimate
    9821575
    9831576    def floor(self):
     1577        """
     1578        Returns the floor of self.
     1579       
     1580        EXAMPLES:
     1581            sage: twinprime.floor()
     1582            0
     1583        """
    9841584        return Integer(0)
    9851585
    9861586    def _repr_(self, simplify=True):
     1587        """
     1588        EXAMPLES:
     1589            sage: repr(twinprime)
     1590            'twinprime'
     1591            sage: twinprime._repr_()
     1592            'twinprime'
     1593        """
    9871594        return 'twinprime'
    9881595
    9891596    def _mpfr_(self, R):
     1597        """
     1598        EXAMPLES:
     1599            sage: RealField(100)(twinprime)
     1600            0.66016181584686957392781211001
     1601            sage: RealField(20000)(twinprime)
     1602            Traceback (most recent call last):
     1603            ...
     1604            NotImplementedError: Twin Prime constant only available up to 3011 bits
     1605        """
    9901606        if R.precision() <= self.__bits:
    9911607            return R(self.__value)
    9921608        raise NotImplementedError, "Twin Prime constant only available up to %s bits"%self.__bits
    class TwinPrime(Constant): 
    10001616        return R('0.660161815846869573927812110014555778432')
    10011617
    10021618    def _real_rqdf_(self, R):
     1619        """
     1620        EXAMPLES:
     1621            sage: RQDF(twinprime)
     1622            0.660161815846869573927812110014555778432623360284733413319448422
     1623        """
    10031624        return R(self.__value[:65])
    10041625   
    10051626    def __float__(self):
    class Merten(Constant): 
    10271648        0.26149721284764278375542683860869585905156664826119920619206
    10281649    """
    10291650    def __init__(self):
     1651        """
     1652        EXAMPLES:
     1653            sage: loads(dumps(merten))
     1654            merten
     1655        """
    10301656        Constant.__init__(self,{'maxima':'merten'}) #Merten's constant is not implemented in any other algebra systems.
    10311657
    10321658        # digits come from Sloane's tables at http://www.research.att.com/~njas/sequences/table?a=77761&fmt=0
    class Merten(Constant): 
    10361662        self.__bits = len(self.__value)*3-1   # underestimate
    10371663
    10381664    def floor(self):
     1665        """
     1666        Returns the floor of self.
     1667       
     1668        EXAMPLES:
     1669            sage: merten.floor()
     1670            0
     1671        """
    10391672        return Integer(0)
    10401673
    10411674    def _repr_(self, simplify=True):
     1675        """
     1676        EXAMPLES:
     1677            sage: merten._repr_()
     1678            'merten'
     1679            sage: repr(merten)
     1680            'merten'
     1681        """
    10421682        return 'merten'
    10431683
    10441684    def _mpfr_(self, R):
    class Merten(Constant): 
    10641704        return R('0.261497212847642783755426838608695859051')
    10651705
    10661706    def _real_rqdf_(self, R):
     1707        """
     1708        EXAMPLES:
     1709            sage: RQDF(merten)
     1710            0.261497212847642783755426838608695859051566648261199206192064212
     1711        """
    10671712        return R(self.__value[:65])
    10681713   
    10691714    def __float__(self):
    class Brun(Constant): 
    10941739        1.90216058310
    10951740    """
    10961741    def __init__(self):
     1742        """
     1743        EXAMPLES:
     1744            sage: loads(dumps(brun))
     1745            brun
     1746        """
    10971747        Constant.__init__(self,{'maxima':"brun"}) #Brun's constant is not implemented in any other algebra systems.
    10981748
    10991749        # digits come from Sloane's tables at http://www.research.att.com/~njas/sequences/table?a=65421&fmt=0
    class Brun(Constant): 
    11031753        self.__bits = len(self.__value)*3-1 # bits  -- todo: make more intelligent in a general function!!!
    11041754
    11051755    def floor(self):
     1756        """
     1757        Return the floor of self.
     1758
     1759        EXAMPLES:
     1760            sage: brun.floor()
     1761            1
     1762        """
    11061763        return Integer(1)
    11071764
    11081765    def _repr_(self, simplify=True):
     1766        """
     1767        EXAMPLES:
     1768            sage: brun._repr_()
     1769            'brun'
     1770            sage: repr(brun)
     1771            'brun'
     1772        """
    11091773        return 'brun'
    11101774
    11111775    def _mpfr_(self, R):
    class Brun(Constant): 
    11141778            sage: RealField(53)(brun)
    11151779            Traceback (most recent call last):
    11161780            ...
    1117             TypeError: Brun's constant only available up to 41 bits
     1781            NotImplementedError: Brun's constant only available up to 41 bits
    11181782            sage: RealField(41)(brun)
    11191783            1.90216058310
    11201784        """
    11211785        if R.precision() <= self.__bits:
    11221786            return R(self.__value)
    1123         raise TypeError, "Brun's constant only available up to %s bits"%self.__bits
     1787        raise NotImplementedError, "Brun's constant only available up to %s bits"%self.__bits
    11241788
    11251789    def _real_double_(self, R):
    11261790        """
    class Brun(Constant): 
    11311795        return R('1.9021605831040')
    11321796
    11331797    def _real_rqdf_(self, R):
    1134         raise TypeError, "Brun's constant only available up to %s bits"%self.__bits
     1798        """
     1799        EXAMPLES:
     1800            sage: RealField(53)(brun)
     1801            Traceback (most recent call last):
     1802            ...
     1803            NotImplementedError: Brun's constant only available up to 41 bits
     1804        """
     1805        raise NotImplementedError, "Brun's constant only available up to %s bits"%self.__bits
    11351806   
    11361807    def __float__(self):
    11371808        """
  • sage/rings/real_double.pyx

    diff -r 85934f3b983c -r c2bd6094a33c sage/rings/real_double.pyx
    a b cdef class RealDoubleElement(FieldElemen 
    855855    # Special Functions
    856856    ############################
    857857
     858    def NaN(self):
     859        """
     860        EXAMPLES:
     861            sage: RDF.NaN()
     862            nan
     863        """
     864        return self(0)/self(0)
     865   
     866    def nan(self):
     867        """
     868        EXAMPLES:
     869            sage: RDF.nan()
     870            nan
     871        """
     872        return self(0)/self(0)
     873   
    858874    def sqrt(self, extend=True, all=False):
    859875        """
    860876        The square root function.