Ticket #9958: trac_9958-fixing_numericalnoise-part2.patch

File trac_9958-fixing_numericalnoise-part2.patch, 26.7 KB (added by fbissey, 10 years ago)

fix numerical noise part 2 (refreshed against 4.7.1.alpha3 -20110625)

  • sage/calculus/calculus.py

    # HG changeset patch
    # User Francois Bissey <francois.bissey@canterbury.ac.nz>
    # Date 1305760213 -43200
    # Node ID 3ae47fe68fe4bb806cdd7753967fef96641030f8
    # Parent  f4d90fd5493d56fd18c39aeed61915c21008c62c
    #9958 fixing numerical noise part 2
    
    diff --git a/sage/calculus/calculus.py b/sage/calculus/calculus.py
    a b  
    221221    sage: n(z,200)
    222222    4.6467837624329358733826155674904591885104869874232887508703
    223223    sage: float(z)
    224     4.6467837624329356
     224    4.646783762432936
    225225
    226226We test pickling::
    227227
     
    642642
    643643        sage: f(x) = exp(-sqrt(x))
    644644        sage: f.nintegral(x, 0, 1)
    645         (0.52848223531423055, 4.163...e-11, 231, 0)
     645        (0.5284822353142306, 4.163...e-11, 231, 0)
    646646
    647647    We can also use the ``numerical_integral`` function,
    648648    which calls the GSL C library.
     
    650650    ::
    651651
    652652        sage: numerical_integral(f, 0, 1)
    653         (0.52848223225314706, 6.83928460...e-07)
     653        (0.528482232253147, 6.83928460...e-07)
    654654
    655655    Note that in exotic cases where floating point evaluation of the
    656656    expression leads to the wrong value, then the output can be
     
    677677    Now numerically integrating, we see why the answer is wrong::
    678678
    679679        sage: f.nintegrate(x,0,1)
    680         (-480.00000000000006, 5.3290705182007538e-12, 21, 0)
     680        (-480.00000000000006, 5.329070518200754e-12, 21, 0)
    681681
    682682    It is just because every floating point evaluation of return -480.0
    683683    in floating point.
  • sage/calculus/test_sympy.py

    diff --git a/sage/calculus/test_sympy.py b/sage/calculus/test_sympy.py
    a b  
    2121    sage: pi^2
    2222    pi^2
    2323    sage: float(pi)
    24     3.1415926535897931
     24    3.141592653589793
    2525    sage: RealField(200)(pi)
    2626    3.1415926535897932384626433832795028841971693993751058209749
    2727    sage: float(pi + exp(1))
  • sage/libs/mpmath/ext_impl.pyx

    diff --git a/sage/libs/mpmath/ext_impl.pyx b/sage/libs/mpmath/ext_impl.pyx
    a b  
    14111411        sage: from sage.libs.mpmath.ext_impl import exp_fixed
    14121412        sage: y = exp_fixed(1<<53, 53)
    14131413        sage: float(y) / 2^53
    1414         2.7182818284590442
     1414        2.718281828459044
    14151415
    14161416    """
    14171417    cdef Integer v
  • sage/libs/mwrank/interface.py

    diff --git a/sage/libs/mwrank/interface.py b/sage/libs/mwrank/interface.py
    a b  
    699699
    700700            sage: E = mwrank_EllipticCurve([0, 0, 0, -1002231243161, 0])
    701701            sage: E.silverman_bound()
    702             18.295452104682472
     702            18.29545210468247
    703703            sage: E = mwrank_EllipticCurve([0,0,1,-7,6])
    704704            sage: E.silverman_bound()
    705             6.2848333699724028
     705            6.284833369972403
    706706        """
    707707        return self.__curve.silverman_bound()
    708708
     
    10221022           
    10231023            sage: E = mwrank_EllipticCurve([0,0,1,-7,6])
    10241024            sage: E.regulator()
    1025             0.41714355875838399
     1025            0.417143558758384
    10261026        """
    10271027        return self.__mw.regulator()
    10281028
  • sage/libs/mwrank/mwrank.pyx

    diff --git a/sage/libs/mwrank/mwrank.pyx b/sage/libs/mwrank/mwrank.pyx
    a b  
    12621262            sage: D2.getbasis()
    12631263            '[[1:-1:1], [-2:3:1], [-14:25:8]]'
    12641264            sage: D2.regulator()
    1265             0.41714355875838399
     1265            0.417143558758384
    12661266        """
    12671267        sig_on()
    12681268        return float(string_sigoff(two_descent_regulator(self.x)))
  • sage/libs/pari/gen.pyx

    diff --git a/sage/libs/pari/gen.pyx b/sage/libs/pari/gen.pyx
    a b  
    17631763            sage: g = pari(-1.0)^(1/5); g
    17641764            0.809016994374947 + 0.587785252292473*I
    17651765            sage: g.__complex__()
    1766             (0.80901699437494745+0.58778525229247314j)
     1766            (0.8090169943749475+0.5877852522924731j)
    17671767            sage: complex(g)           
    1768             (0.80901699437494745+0.58778525229247314j)
     1768            (0.8090169943749475+0.5877852522924731j)
    17691769       
    17701770        ::
    17711771       
  • sage/numerical/optimize.py

    diff --git a/sage/numerical/optimize.py b/sage/numerical/optimize.py
    a b  
    4444        sage: R.<x> = QQ[]
    4545        sage: f = (x+17)*(x-3)*(x-1/8)^3
    4646        sage: find_root(f, 0,4)
    47         2.9999999999999951
     47        2.999999999999995
    4848        sage: find_root(f, 0,1)  # note -- precision of answer isn't very good on some machines.
    4949        0.124999...
    5050        sage: find_root(f, -20,-10)
  • sage/plot/misc.py

    diff --git a/sage/plot/misc.py b/sage/plot/misc.py
    a b  
    6868        sage: sage.plot.misc.setup_for_eval_on_grid([x+y], [(x,-1,1),(y,-2,2)])
    6969        ((<sage.ext...>,), [(-1.0, 1.0, 2.0), (-2.0, 2.0, 4.0)])
    7070        sage: sage.plot.misc.setup_for_eval_on_grid(x+y, [(x,-1,1),(y,-1,1)], plot_points=[4,9])
    71         (<sage.ext...>, [(-1.0, 1.0, 0.66666666666666663), (-1.0, 1.0, 0.25)])
     71        (<sage.ext...>, [(-1.0, 1.0, 0.6666666666666666), (-1.0, 1.0, 0.25)])
    7272        sage: sage.plot.misc.setup_for_eval_on_grid(x+y, [(x,-1,1),(y,-1,1)], plot_points=[4,9,10])
    7373        Traceback (most recent call last):
    7474        ...
  • sage/plot/plot.py

    diff --git a/sage/plot/plot.py b/sage/plot/plot.py
    a b  
    984984       
    985985            sage: p = plot(cos, (-3,3))
    986986            sage: p.axes_width()
    987             0.80000000000000004
     987            0.8
    988988            sage: p.axes_width(10)
    989989            sage: p.axes_width()
    990990            10.0
     
    39323932        doctest:...: DeprecationWarning: sage.plot.plot.setup_for_eval_on_grid is deprecated.  Please use sage.plot.misc.setup_for_eval_on_grid; note that that function has slightly different calling and return conventions which make it more generally applicable
    39333933        ([<sage.ext... object at ...>],
    39343934         0.5,
    3935          0.31415926535897931,
     3935         0.3141592653589793,
    39363936         (0.0, 5.0),
    3937          (0.0, 3.1415926535897931))
     3937         (0.0, 3.141592653589793))
    39383938
    39393939    We always plot at least two points; one at the beginning and one at the end of the ranges.
    39403940
     
    40224022        sage: adaptive_refinement(sin, (0,0), (pi,0), adaptive_tolerance=0.01, adaptive_recursion=0)
    40234023        []
    40244024        sage: adaptive_refinement(sin, (0,0), (pi,0), adaptive_tolerance=0.01)
    4025         [(0.125*pi, 0.38268343236508978), (0.1875*pi, 0.55557023301960218), (0.25*pi, 0.70710678118654746), (0.3125*pi, 0.83146961230254524), (0.375*pi, 0.92387953251128674), (0.4375*pi, 0.98078528040323043), (0.5*pi, 1.0), (0.5625*pi, 0.98078528040323043), (0.625*pi, 0.92387953251128674), (0.6875*pi, 0.83146961230254546), (0.75*pi, 0.70710678118654757), (0.8125*pi, 0.55557023301960218), (0.875*pi, 0.38268343236508989)]
     4025        [(0.125*pi, 0.3826834323650898), (0.1875*pi, 0.5555702330196022), (0.25*pi, 0.7071067811865475), (0.3125*pi, 0.8314696123025452), (0.375*pi, 0.9238795325112867), (0.4375*pi, 0.9807852804032304), (0.5*pi, 1.0), (0.5625*pi, 0.9807852804032304), (0.625*pi, 0.9238795325112867), (0.6875*pi, 0.8314696123025455), (0.75*pi, 0.7071067811865476), (0.8125*pi, 0.5555702330196022), (0.875*pi, 0.3826834323650899)]
    40264026
    40274027    This shows that lowering adaptive_tolerance and raising
    40284028    adaptive_recursion both increase the number of subdivision
     
    41094109
    41104110        sage: from sage.plot.plot import generate_plot_points
    41114111        sage: generate_plot_points(sin, (0, pi), plot_points=2, adaptive_recursion=0)
    4112         [(0.0, 0.0), (3.1415926535897931, 1.2246...e-16)]
     4112        [(0.0, 0.0), (3.141592653589793, 1.2246...e-16)]
    41134113
    41144114        sage: from sage.plot.plot import generate_plot_points
    41154115        sage: generate_plot_points(lambda x: x^2, (0, 6), plot_points=2, adaptive_recursion=0, initial_points = [1,2,3])
    41164116        [(0.0, 0.0), (1.0, 1.0), (2.0, 4.0), (3.0, 9.0), (6.0, 36.0)]
    41174117
    41184118        sage: generate_plot_points(sin(x).function(x), (-pi, pi), randomize=False)
    4119         [(-3.1415926535897931, -1.2246...e-16), (-2.748893571891069,
    4120         -0.3826834323650898...), (-2.3561944901923448, -0.707106781186547...),
     4119        [(-3.141592653589793, -1.2246...e-16), (-2.748893571891069,
     4120        -0.3826834323650899), (-2.356194490192345, -0.707106781186547...),
    41214121        (-2.1598449493429825, -0.831469612302545...), (-1.9634954084936207,
    4122         -0.92387953251128674), (-1.7671458676442586, -0.98078528040323043),
     4122        -0.9238795325112867), (-1.7671458676442586, -0.9807852804032304),
    41234123        (-1.5707963267948966, -1.0), (-1.3744467859455345,
    4124         -0.98078528040323043), (-1.1780972450961724, -0.92387953251128674),
    4125         (-0.98174770424681035, -0.831469612302545...), (-0.78539816339744828,
    4126         -0.707106781186547...), (-0.39269908169872414, -0.38268343236508978),
    4127         (0.0, 0.0), (0.39269908169872414, 0.38268343236508978),
    4128         (0.78539816339744828, 0.707106781186547...), (0.98174770424681035,
    4129         0.831469612302545...), (1.1780972450961724, 0.92387953251128674),
    4130         (1.3744467859455345, 0.98078528040323043), (1.5707963267948966, 1.0),
    4131         (1.7671458676442586, 0.98078528040323043), (1.9634954084936207,
    4132         0.92387953251128674), (2.1598449493429825, 0.831469612302545...),
    4133         (2.3561944901923448, 0.707106781186547...), (2.748893571891069,
    4134         0.3826834323650898...), (3.1415926535897931, 1.2246...e-16)]
     4124        -0.9807852804032304), (-1.1780972450961724, -0.9238795325112867),
     4125        (-0.9817477042468103, -0.831469612302545...), (-0.7853981633974483,
     4126        -0.707106781186547...), (-0.39269908169872414, -0.3826834323650898),
     4127        (0.0, 0.0), (0.39269908169872414, 0.3826834323650898),
     4128        (0.7853981633974483, 0.707106781186547...), (0.9817477042468103,
     4129        0.831469612302545...), (1.1780972450961724, 0.9238795325112867),
     4130        (1.3744467859455345, 0.9807852804032304), (1.5707963267948966, 1.0),
     4131        (1.7671458676442586, 0.9807852804032304), (1.9634954084936207,
     4132        0.9238795325112867), (2.1598449493429825, 0.831469612302545...),
     4133        (2.356194490192345, 0.707106781186547...), (2.748893571891069,
     4134        0.3826834323650899), (3.141592653589793, 1.2246...e-16)]
    41354135
    41364136    This shows that lowering adaptive_tolerance and raising
    41374137    adaptive_recursion both increase the number of subdivision points.
  • sage/plot/plot3d/base.pyx

    diff --git a/sage/plot/plot3d/base.pyx b/sage/plot/plot3d/base.pyx
    a b  
    14841484            sage: G.scale(4).bounding_box()
    14851485            ((-2.0, -2.0, -2.0), (2.0, 2.0, 2.0))
    14861486            sage: G.rotateZ(pi/4).bounding_box()
    1487             ((-0.70710678118654746, -0.70710678118654746, -0.5),
    1488              (0.70710678118654746, 0.70710678118654746, 0.5))
     1487            ((-0.7071067811865475, -0.7071067811865475, -0.5),
     1488             (0.7071067811865475, 0.7071067811865475, 0.5))
    14891489        """
    14901490        try:
    14911491            return self._bounding_box
  • sage/plot/plot3d/index_face_set.pyx

    diff --git a/sage/plot/plot3d/index_face_set.pyx b/sage/plot/plot3d/index_face_set.pyx
    a b  
    511511            sage: x,y=var('x,y')
    512512            sage: p=plot3d(sqrt(sin(x)*sin(y)), (x,0,2*pi),(y,0,2*pi))
    513513            sage: p.bounding_box()
    514             ((0.0, 0.0, -0.0), (6.2831853071795862, 6.2831853071795862, 0.9991889981715697))
     514            ((0.0, 0.0, -0.0), (6.283185307179586, 6.283185307179586, 0.9991889981715697))
    515515        """
    516516        if self.vcount == 0:
    517517            return ((0,0,0),(0,0,0))
  • sage/plot/plot3d/parametric_surface.pyx

    diff --git a/sage/plot/plot3d/parametric_surface.pyx b/sage/plot/plot3d/parametric_surface.pyx
    a b  
    309309            sage: from sage.plot.plot3d.parametric_surface import MobiusStrip
    310310            sage: M = MobiusStrip(7,3,2)
    311311            sage: M.bounding_box()
    312             ((-10.0, -7.53907349250478..., -2.9940801852848145), (10.0, 7.5390734925047846, 2.9940801852848145))
     312            ((-10.0, -7.53907349250478..., -2.9940801852848145), (10.0, 7.53907349250478..., 2.9940801852848145))
    313313        """
    314314        # We must triangulate before computing the bounding box; otherwise
    315315        # we'll get an empty bounding box, as the bounding box is computed
  • sage/plot/plot3d/shapes.pyx

    diff --git a/sage/plot/plot3d/shapes.pyx b/sage/plot/plot3d/shapes.pyx
    a b  
    746746            sage: from sage.plot.plot3d.shapes import Sphere
    747747            sage: Sphere(1).get_grid(100)
    748748            ([-10.0, ..., 0.0, ..., 10.0],
    749              [0.0, ..., 3.1415926535897931, ..., 0.0])
     749             [0.0, ..., 3.141592653589793, ..., 0.0])
    750750        """
    751751        cdef int K, u_res, v_res
    752752        u_res = min(max(int(M_PI*self.radius/ds), 6), 20)
     
    811811       
    812812            sage: from sage.plot.plot3d.shapes import Torus
    813813            sage: Torus(2, 1).get_grid(100)
    814             ([0.0, -1.047..., -3.1415926535897931, ..., 0.0],
    815              [0.0, 1.047..., 3.1415926535897931, ..., 0.0])
     814            ([0.0, -1.047..., -3.141592653589793, ..., 0.0],
     815             [0.0, 1.047..., 3.141592653589793, ..., 0.0])
    816816        """
    817817        cdef int k, u_divs, v_divs
    818818        u_divs = min(max(int(4*M_PI * self.R/ds), 6), 37)
  • sage/plot/plot3d/shapes2.py

    diff --git a/sage/plot/plot3d/shapes2.py b/sage/plot/plot3d/shapes2.py
    a b  
    811811            sage: from sage.plot.plot3d.shapes2 import Line
    812812            sage: L = Line([(i,i^2-1,-2*ln(i)) for i in [10,20,30]])
    813813            sage: L.bounding_box()
    814             ((10.0, 99.0, -6.8023947633243109), (30.0, 899.0, -4.6051701859880918))
     814            ((10.0, 99.0, -6.802394763324311), (30.0, 899.0, -4.605170185988092))
    815815        """
    816816        try:
    817817            return self.__bounding_box
  • sage/rings/complex_number.pyx

    diff --git a/sage/rings/complex_number.pyx b/sage/rings/complex_number.pyx
    a b  
    853853            sage: a.__abs__()
    854854            2.23606797749979
    855855            sage: float(sqrt(2^2 + 1^1))
    856             2.2360679774997898
     856            2.23606797749979
    857857       
    858858        ::
    859859       
  • sage/rings/contfrac.py

    diff --git a/sage/rings/contfrac.py b/sage/rings/contfrac.py
    a b  
    631631            sage: a = CFF(-17/389); a
    632632            [-1, 1, 21, 1, 7, 2]
    633633            sage: float(a)
    634             -0.043701799485861177
     634            -0.04370179948586118
    635635        """
    636636        return float(self._rational_())
    637637
     
    747747            sage: b.value()
    748748            4508361/9825745
    749749            sage: float(b.value()^2 - a)
    750             -5.4514925256726876e-16
     750            -5.451492525672688e-16
    751751            sage: b = a.sqrt(prec=100); b
    752752            [0, 2, 5, 1, 1, 2, 1, 16, 1, 2, 1, 1, 5, 4, 5, 1, 1, 2, 1, 16, 1, 2, 1, 1, 5, 4, 5, 1, 1, 2, 1, 16, 1, 2, 1, 1, 5]
    753753            sage: b^2
  • sage/rings/integer.pyx

    diff --git a/sage/rings/integer.pyx b/sage/rings/integer.pyx
    a b  
    29542954            sage: n = Integer(17); float(n)
    29552955            17.0
    29562956            sage: n = Integer(902834098234908209348209834092834098); float(n)
    2957             9.0283409823490813e+35
     2957            9.028340982349081e+35
    29582958            sage: n = Integer(-57); float(n)
    29592959            -57.0
    29602960            sage: n.__float__()
  • sage/rings/number_field/totallyreal.pyx

    diff --git a/sage/rings/number_field/totallyreal.pyx b/sage/rings/number_field/totallyreal.pyx
    a b  
    157157    EXAMPLES::
    158158   
    159159        sage: [sage.rings.number_field.totallyreal.odlyzko_bound_totallyreal(n) for n in range(1,5)]
    160         [1.0, 2.2229999999999999, 3.6099999999999999, 5.0670000000000002]
     160        [1.0, 2.223, 3.61, 5.067]
    161161
    162162    AUTHORS:
    163163   
  • sage/rings/polynomial/real_roots.pyx

    diff --git a/sage/rings/polynomial/real_roots.pyx b/sage/rings/polynomial/real_roots.pyx
    a b  
    18071807
    18081808        sage: from sage.rings.polynomial.real_roots import *
    18091809        sage: max_abs_doublevec(vector(RDF, [0.1, -0.767, 0.3, 0.693]))
    1810         0.76700000000000002
     1810        0.767
    18111811    """
    18121812    cdef numpy.ndarray[double, ndim=1] cd = c._vector_numpy
    18131813
  • sage/rings/qqbar.py

    diff --git a/sage/rings/qqbar.py b/sage/rings/qqbar.py
    a b  
    454454    ...               return None
    455455    ...       return map(convert_test, all_vals)
    456456    sage: convert_test_all(float)
    457     [42.0, 3.1428571428571432, 1.6180339887498949, -13.0, 1.6181818181818182, -2.6457513110645907, None]
     457    [42.0, 3.1428571428571432, 1.618033988749895, -13.0, 1.6181818181818182, -2.6457513110645907, None]
    458458    sage: convert_test_all(complex)
    459     [(42+0j), (3.1428571428571432+0j), (1.6180339887498949+0j), (-13+0j), (1.6181818181818182+0j), (-2.6457513110645907+0j), (0.30901699437494745+0.95105651629515364j)]
     459    [(42+0j), (3.1428571428571432+0j), (1.618033988749895+0j), (-13+0j), (1.6181818181818182+0j), (-2.6457513110645907+0j), (0.30901699437494745+0.9510565162951536j)]
    460460    sage: convert_test_all(RDF)
    461461    [42.0, 3.14285714286, 1.61803398875, -13.0, 1.61818181818, -2.64575131106, None]
    462462    sage: convert_test_all(CDF)
     
    31133113        EXAMPLES::
    31143114
    31153115            sage: QQbar(sqrt(2)).__float__()
    3116             1.4142135623730949
     3116            1.414213562373095
    31173117            sage: float(QQbar(-22/7))
    31183118            -3.1428571428571432
    31193119            sage: float(QQbar.zeta(3))
     
    31303130        EXAMPLES::
    31313131
    31323132            sage: QQbar(sqrt(2)).__complex__()
    3133             (1.4142135623730949+0j)
     3133            (1.414213562373095+0j)
    31343134            sage: complex(QQbar.zeta(3))
    31353135            (-0.5+0.8660254037844386j)
    31363136        """
     
    37723772        EXAMPLES::
    37733773
    37743774            sage: AA(golden_ratio).__float__()
    3775             1.6180339887498949
     3775            1.618033988749895
    37763776            sage: float(AA(sqrt(11)))
    3777             3.3166247903553998
     3777            3.3166247903554
    37783778        """
    37793779        return float(RR(self))
    37803780
  • sage/rings/quotient_ring_element.py

    diff --git a/sage/rings/quotient_ring_element.py b/sage/rings/quotient_ring_element.py
    a b  
    494494            sage: R.<x,y> = QQ[]; S.<a,b> = R.quo(x^2 + y^2); type(a)
    495495            <class 'sage.rings.quotient_ring_element.QuotientRingElement'>
    496496            sage: float(S(2/3))
    497             0.66666666666666663
     497            0.6666666666666666
    498498            sage: float(a)
    499499            Traceback (most recent call last):
    500500            ...
  • sage/rings/real_lazy.pyx

    diff --git a/sage/rings/real_lazy.pyx b/sage/rings/real_lazy.pyx
    a b  
    12021202            sage: from sage.rings.real_lazy import LazyConstant
    12031203            sage: a = LazyConstant(RLF, 'pi')
    12041204            sage: float(a)
    1205             3.1415926535897931
     1205            3.141592653589793
    12061206        """
    12071207        interval_field = self._parent.interval_field()
    12081208        return <double>self.eval(interval_field._middle_field())
  • sage/structure/coerce_dict.pyx

    diff --git a/sage/structure/coerce_dict.pyx b/sage/structure/coerce_dict.pyx
    a b  
    5151        sage: len(L)
    5252        1
    5353        sage: L.stats()             # min, avg, max (bucket length)
    54         (0, 0.032258064516129031, 1)
     54        (0, 0.03225806451612903, 1)
    5555        sage: L.bucket_lens()       # random layout
    5656        [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    5757        sage: for i in range(1000):
  • sage/symbolic/constants.py

    diff --git a/sage/symbolic/constants.py b/sage/symbolic/constants.py
    a b  
    546546        EXAMPLES::
    547547       
    548548            sage: float(pi)
    549             3.1415926535897931
     549            3.141592653589793
    550550        """
    551551        return math.pi
    552552
     
    737737        sage: grm + grm
    738738        sqrt(5)+1
    739739        sage: float(grm + grm)
    740         3.2360679774997898
     740        3.23606797749979
    741741    """
    742742    def __init__(self, name='golden_ratio'):
    743743        """
     
    769769        EXAMPLES::
    770770       
    771771            sage: float(golden_ratio)
    772             1.6180339887498949
     772            1.618033988749895
    773773            sage: golden_ratio.__float__()
    774             1.6180339887498949
     774            1.618033988749895
    775775        """
    776776        return float(0.5)*(float(1.0)+math.sqrt(float(5.0)))
    777777
     
    832832        sage: log2
    833833        log2
    834834        sage: float(log2)
    835         0.69314718055994529
     835        0.6931471805599453
    836836        sage: RR(log2)
    837837        0.693147180559945
    838838        sage: R = RealField(200); R
     
    871871        EXAMPLES::
    872872       
    873873            sage: float(log2)
    874             0.69314718055994529
     874            0.6931471805599453
    875875            sage: log2.__float__()
    876             0.69314718055994529
     876            0.6931471805599453
    877877        """
    878878        return math.log(2)
    879879
     
    948948        EXAMPLES::
    949949
    950950            sage: float(euler_gamma)
    951             0.57721566490153287
     951            0.5772156649015329
    952952        """
    953953        return 0.57721566490153286060651209008
    954954
     
    10271027        EXAMPLES::
    10281028       
    10291029            sage: float(catalan)
    1030             0.91596559417721901
     1030            0.915965594177219
    10311031        """
    10321032        return 0.91596559417721901505460351493252
    10331033
     
    11401140        EXAMPLES::
    11411141
    11421142            sage: float(twinprime)
    1143             0.66016181584686962
     1143            0.6601618158468696
    11441144        """
    11451145        return 0.66016181584686957392781211001
    11461146
  • sage/symbolic/expression.pyx

    diff --git a/sage/symbolic/expression.pyx b/sage/symbolic/expression.pyx
    a b  
    953953            sage: float(SR(12))
    954954            12.0
    955955            sage: float(SR(2/3))
    956             0.66666666666666663
     956            0.6666666666666666
    957957            sage: float(sqrt(SR(2)))
    958958            1.4142135623730951
    959959            sage: float(x^2 + 1)
     
    23962396            sage: cmp(sin(SR(2)), sin(SR(1)))
    23972397            1
    23982398            sage: float(sin(SR(2)))
    2399             0.90929742682568171
     2399            0.9092974268256817
    24002400            sage: float(sin(SR(1)))
    24012401            0.8414709848078965
    24022402        """
     
    24692469            sage: int(2)^x
    24702470            2^x
    24712471            sage: float(2.3)^(x^3 - x^2 + 1/3)
    2472             2.2999999999999998^(x^3 - x^2 + 1/3)
     2472            2.3^(x^3 - x^2 + 1/3)
    24732473            sage: complex(1,3)^(sqrt(2))
    24742474            (1+3j)^sqrt(2)
    24752475        """
     
    54665466            sage: maxima('atan2(0.7,0.6)')
    54675467            .862170054667226...
    54685468            sage: float(SR(0.7).arctan2(-0.6))
    5469             2.2794225989225669
     5469            2.279422598922567
    54705470            sage: maxima('atan2(0.7,-0.6)')
    54715471            2.279422598922567
    54725472            sage: float(SR(-0.7).arctan2(0.6))
     
    54745474            sage: maxima('atan2(-0.7,0.6)')
    54755475            -.862170054667226...
    54765476            sage: float(SR(-0.7).arctan2(-0.6))
    5477             -2.2794225989225669
     5477            -2.279422598922567
    54785478            sage: maxima('atan2(-0.7,-0.6)')
    54795479            -2.279422598922567
    54805480            sage: float(SR(0).arctan2(-0.6))
     
    59345934            sage: SR(0.5).log().exp()
    59355935            0.500000000000000
    59365936            sage: math.log(0.5)
    5937             -0.69314718055994529
     5937            -0.6931471805599453
    59385938            sage: plot(lambda x: SR(x).log(), 0.1,10)
    59395939
    59405940        To prevent automatic evaluation use the ``hold`` argument::
     
    77707770        An example with a square root::
    77717771       
    77727772            sage: f = 1 + x + sqrt(x+2); f.find_root(-2,10)
    7773             -1.6180339887498949
     7773            -1.618033988749895
    77747774       
    77757775        Some examples that Ted Kosan came up with::
    77767776       
  • sage/symbolic/function.pyx

    diff --git a/sage/symbolic/function.pyx b/sage/symbolic/function.pyx
    a b  
    180180            sage: cot(0.5) #indirect doctest
    181181            1.83048772171245
    182182            sage: cot(complex(1,2))
    183             (0.032797755533752602-0.98432922645819...j)
     183            (0.0327977555337526-0.98432922645819...j)
    184184        """
    185185        if isinstance(x, (int, long)):
    186186            return None
     
    299299            sage: arctan(1)
    300300            1/4*pi
    301301            sage: arctan(float(1))
    302             0.78539816339744828
     302            0.7853981633974483
    303303
    304304        Precision of the result depends on the precision of the input::
    305305
     
    554554            sage: ff.is_pure_c()
    555555            False
    556556            sage: ff(1.5)
    557             0.96610514647531076
     557            0.9661051464753108
    558558            sage: erf(1.5)
    559559            0.966105146475311
    560560        """
  • sage/symbolic/integration/integral.py

    diff --git a/sage/symbolic/integration/integral.py b/sage/symbolic/integration/integral.py
    a b  
    503503        sage: res.subs(y=2).n()
    504504        1.46383232641443
    505505        sage: nres = numerical_integral(f.subs(y=.5), 0.0001414, 1.); nres
    506         (-0.66951170887280698, 7.7686781108547113e-15)
     506        (-0.669511708872807, 7.768678110854711e-15)
    507507        sage: res.subs(y=.5).n()
    508508        -0.669511708872807
    509509
  • sage/symbolic/pynac.pyx

    diff --git a/sage/symbolic/pynac.pyx b/sage/symbolic/pynac.pyx
    a b  
    11031103    TESTS::
    11041104
    11051105        sage: sin(float(2)) #indirect doctest
    1106         0.90929742682568171
     1106        0.9092974268256817
    11071107        sage: sin(2.)
    11081108        0.909297426825682
    11091109        sage: sin(2.*I)
     
    11241124    """
    11251125    TESTS::
    11261126        sage: cos(float(2)) #indirect doctest
    1127         -0.41614683654714241
     1127        -0.4161468365471424
    11281128        sage: cos(2.)
    11291129        -0.416146836547142
    11301130        sage: cos(2.*I)
     
    12411241        sage: py_log(float(0))
    12421242        -inf
    12431243        sage: py_log(float(-1))
    1244         3.1415926535897931j
     1244        3.141592653589793j
    12451245        sage: py_log(int(1))
    12461246        0.0
    12471247        sage: py_log(long(1))
  • sage/symbolic/random_tests.py

    diff --git a/sage/symbolic/random_tests.py b/sage/symbolic/random_tests.py
    a b  
    8383        sage: B = [(1, 'B1'), (2, 'B2'), (2, 'B3')]
    8484        sage: top = [(50, A, 'Group A'), (50, B, 'Group B')]
    8585        sage: normalize_prob_list(top)
    86         [(0.250000000000000, 'A1', 'Group A'), (0.250000000000000, 'A2', 'Group A'), (0.10000000000000001, 'B1', 'Group B'), (0.20000000000000001, 'B2', 'Group B'), (0.20000000000000001, 'B3', 'Group B')]
     86        [(0.250000000000000, 'A1', 'Group A'), (0.250000000000000, 'A2', 'Group A'), (0.1, 'B1', 'Group B'), (0.2, 'B2', 'Group B'), (0.2, 'B3', 'Group B')]
    8787    """
    8888    if len(pl) == 0:
    8989        return pl
  • sage/symbolic/relation.py

    diff --git a/sage/symbolic/relation.py b/sage/symbolic/relation.py
    a b  
    154154    sage: (x == sin(x)).find_root(-2,2)
    155155    0.0
    156156    sage: (x^5 + 3*x + 2 == 0).find_root(-2,2,x)
    157     -0.63283452024215225
     157    -0.6328345202421523
    158158    sage: (cos(x) == sin(x)).find_root(10,20)
    159159    19.634954084936208
    160160