Issue #5859: Remove '%f' to '%g' formatting switch for large floats.

diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 72e2fb44b75beb5e25fe66a2e61b30c06aea101f..c8c2c801aea6266bf6866e292eea47517b119ec6 100644 (file)
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -1321,9 +1321,9 @@ that ``'\0'`` is the end of the string.
 
 .. XXX Examples?
 
-For safety reasons, floating point precisions are clipped to 50; ``%f``
-conversions for numbers whose absolute value is over 1e50 are replaced by ``%g``
-conversions. [#]_  All other errors raise exceptions.
+.. versionchanged:: 3.1
+   ``%f`` conversions for numbers whose absolute value is over 1e50 are no
+   longer replaced by ``%g`` conversions.
 
 .. index::
    module: string
@@ -2723,10 +2723,6 @@ The following attributes are only supported by :term:`new-style class`\ es.
 .. [#] To format only a tuple you should therefore provide a singleton tuple whose only
    element is the tuple to be formatted.
 
-.. [#] These numbers are fairly arbitrary.  They are intended to avoid printing endless
-   strings of meaningless digits without hampering correct use and without having
-   to know the exact precision of floating point values on a particular machine.
-
 .. [#] The advantage of leaving the newline on is that returning an empty string is
    then an unambiguous EOF indication.  It is also possible (in cases where it
    might matter, for example, if you want to make an exact copy of a file while

diff --git a/Lib/test/formatfloat_testcases.txt b/Lib/test/formatfloat_testcases.txt
index 287019f929edecb8dc2ba09b14a1e549105d2d2e..4cf20aa8c9b0f97c55383db403fe9941c5bd830a 100644 (file)
--- a/Lib/test/formatfloat_testcases.txt
+++ b/Lib/test/formatfloat_testcases.txt
@@ -22,8 +22,8 @@
 %.0f 123.456 -> 123
 %.0f 1234.56 -> 1235
 %.0f 1e49 -> 9999999999999999464902769475481793196872414789632
--- %.0f 1e50 -> 100000000000000007629769841091887003294964970946560
 %.0f 9.9999999999999987e+49 -> 99999999999999986860582406952576489172979654066176
+%.0f 1e50 -> 100000000000000007629769841091887003294964970946560
 
 -- precision 1
 %.1f 0.0001 -> 0.0

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 230b1023422e8abf16b05fe4f78b4a209cc6485b..b85d337481fa893ce2892ad8c02f50d0d747c026 100644 (file)
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -538,10 +538,25 @@ class TypesTests(unittest.TestCase):
         test(-1.0, ' f', '-1.000000')
         test( 1.0, '+f', '+1.000000')
         test(-1.0, '+f', '-1.000000')
-        test(1.1234e90, 'f', '1.1234e+90')
-        test(1.1234e90, 'F', '1.1234e+90')
-        test(1.1234e200, 'f', '1.1234e+200')
-        test(1.1234e200, 'F', '1.1234e+200')
+
+        # Python versions <= 3.0 switched from 'f' to 'g' formatting for
+        # values larger than 1e50.  No longer.
+        f = 1.1234e90
+        for fmt in 'f', 'F':
+            # don't do a direct equality check, since on some
+            # platforms only the first few digits of dtoa
+            # will be reliable
+            result = f.__format__(fmt)
+            self.assertEqual(len(result), 98)
+            self.assertEqual(result[-7], '.')
+            self.assert_(result[:12] in ('112340000000', '112339999999'))
+        f = 1.1234e200
+        for fmt in 'f', 'F':
+            result = f.__format__(fmt)
+            self.assertEqual(len(result), 208)
+            self.assertEqual(result[-7], '.')
+            self.assert_(result[:12] in ('112340000000', '112339999999'))
+
 
         test( 1.0, 'e', '1.000000e+00')
         test(-1.0, 'e', '-1.000000e+00')

diff --git a/Misc/NEWS b/Misc/NEWS
index 3e8f5e6478e3fd572962cb974faecd7e3df51c3b..d6ea20999ff3b62d08e36b2a7ab24a82a4982057 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,8 +12,10 @@ What's New in Python 3.1 beta 1?
 Core and Builtins
 -----------------
 
-- Issue #5859: Remove length restrictions for float formatting:
-  '%.67f' % 12.34 and '%.120e' % 12.34 no longer raise an exception.
+- Issue #5859: Remove switch from '%f' to '%g'-style formatting for
+  floats with absolute value over 1e50.  Also remove length
+  restrictions for float formatting: '%.67f' % 12.34 and '%.120e' %
+  12.34 no longer raise an exception.
 
 - Issue #1588: Add complex.__format__. For example, 
   format(complex(1, 2./3), '.5') now produces a sensible result.

diff --git a/Objects/stringlib/formatter.h b/Objects/stringlib/formatter.h
index c5cda4cebf9fda12bf2139124f7aca3b7c26364d..d9d47b9f49d8a8402e18857f479b6ea2df3ff21f 100644 (file)
--- a/Objects/stringlib/formatter.h
+++ b/Objects/stringlib/formatter.h
@@ -934,8 +934,6 @@ format_float_internal(PyObject *value,
 
     if (precision < 0)
         precision = 6;
-    if ((type == 'f' || type == 'F') && fabs(val) >= 1e50)
-        type = 'g';
 
     /* Cast "type", because if we're in unicode we need to pass a
        8-bit char. This is safe, because we've restricted what "type"

diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 31b9a73683c052d72660f2e6016576141ba4b88f..68d4fc41ae92e1394c03d953b6523170d29322bf 100644 (file)
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -8808,9 +8808,6 @@ formatfloat(PyObject *v, int flags, int prec, int type)
     if (prec < 0)
         prec = 6;
 
-    if (type == 'f' && fabs(x) >= 1e50)
-        type = 'g';
-
     p = PyOS_double_to_string(x, type, prec,
                               (flags & F_ALT) ? Py_DTSF_ALT : 0, NULL);
     if (p == NULL)