+1

Author: skirpichev

Doc/c-api/conversion.rst

@@ -88,7 +88,7 @@ The following functions provide locale-independent string to number conversions.
    *format_code*, *precision*, and *flags*.
 
    *format_code* must be one of ``'e'``, ``'E'``, ``'f'``, ``'F'``,
-   ``'g'``, ``'G'`` or ``'r'``.  For ``'r'``, the supplied *precision*
+   ``'g'``, ``'G'``, ``'x'``, ``'X'`` or ``'r'``.  For ``'r'``, the supplied *precision*
    must be 0 and is ignored.  The ``'r'`` format code specifies the
    standard :func:`repr` format.
 
@@ -115,6 +115,9 @@ The following functions provide locale-independent string to number conversions.
 
    .. versionadded:: 3.1
 
+.. versionchanged:: 3.13
+   Support ``'x'`` and ``'X'`` format types for :class:`float`.
+
 
 .. c:function:: int PyOS_stricmp(const char *s1, const char *s2)
 

Doc/library/stdtypes.rst

@@ -2430,9 +2430,9 @@ The conversion types are:
 +------------+-----------------------------------------------------+-------+
 | ``'u'``    | Obsolete type -- it is identical to ``'d'``.        | \(6)  |
 +------------+-----------------------------------------------------+-------+
-| ``'x'``    | Signed hexadecimal (lowercase).                     | \(2)  |
+| ``'x'``    | Signed hexadecimal integer or float (lowercase).    | \(2)  |
 +------------+-----------------------------------------------------+-------+
-| ``'X'``    | Signed hexadecimal (uppercase).                     | \(2)  |
+| ``'X'``    | Signed hexadecimal integer or float (uppercase).    | \(2)  |
 +------------+-----------------------------------------------------+-------+
 | ``'e'``    | Floating point exponential format (lowercase).      | \(3)  |
 +------------+-----------------------------------------------------+-------+
@@ -2473,8 +2473,19 @@ Notes:
    inserted before the first digit.
 
 (2)
-   The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on whether
-   the ``'x'`` or ``'X'`` format was used) to be inserted before the first digit.
+   The alternate form for an integer causes a leading ``'0x'`` or ``'0X'``
+   (depending on whether the ``'x'`` or ``'X'`` format was used) to be
+   inserted before the first digit.
+
+   For floats, represent the number by a hexadecimal string in the style
+   ``[±]0xh.[hhhp±d``, where there is one hexadecimal digit before the
+   decimal-point character and the number of hexadecimal digits after it is
+   equal to the precision; if the precision is missing, then the precision is
+   sufficient for an exact representation of the value.  If the precision is
+   zero and the alternate form is not specified, no decimal-point character
+   appears.  The exponent ``d`` is written in decimal, it always contains at
+   least one digit, and it gives the power of 2 by which to multiply the
+   coefficient.
 
 (3)
    The alternate form causes the result to always contain a decimal point, even if
@@ -2505,6 +2516,9 @@ that ``'\0'`` is the end of the string.
    ``%f`` conversions for numbers whose absolute value is over 1e50 are no
    longer replaced by ``%g`` conversions.
 
+.. versionchanged:: 3.13
+   Support ``'x'`` and ``'X'`` format types for :class:`float`.
+
 
 .. index::
    single: buffer protocol; binary sequence types

Lib/test/test_float.py

@@ -700,11 +700,19 @@ def test_format(self):
         # % formatting
         self.assertEqual(format(-1.0, '%'), '-100.000000%')
 
+        # hexadecimal format
+        self.assertEqual(format(float.fromhex('0x0.0030p+0'), 'x'), '0x1.8p-11')
+        self.assertEqual(format(float.fromhex('0x0.0040p+0'), 'x'), '0x1p-10')
+        self.assertEqual(format(float.fromhex('0x0.0040p+0'), '>10x'), '   0x1p-10')
+        self.assertEqual(format(float.fromhex('0x0.0040p+0'), '>#10x'), '  0x1.p-10')
+        self.assertEqual(format(float.fromhex('0x0.0040p+0'), '<10x'), '0x1p-10   ')
+        self.assertEqual(format(float.fromhex('0x0.0040p+0'), '<#10x'), '0x1.p-10  ')
+
         # conversion to string should fail
         self.assertRaises(ValueError, format, 3.0, "s")
 
-        # confirm format options expected to fail on floats, such as integer
-        # presentation types
+        # confirm format options expected to fail on floats, such as some
+        # integer presentation types
         for format_spec in 'sbcdo':
             self.assertRaises(ValueError, format, 0.0, format_spec)
             self.assertRaises(ValueError, format, 1.0, format_spec)

Lib/test/test_format.py

@@ -269,6 +269,13 @@ def test_common_format(self):
         testcommon('%g', 1.1, '1.1')
         testcommon('%#g', 1.1, '1.10000')
 
+        # hexadecimal floats
+        testcommon("%x", 3.14, '0x1.91eb851eb851fp+1')
+        testcommon("%X", 3.14, '0X1.91EB851EB851FP+1')
+        testcommon("%+.3x", 3.14, '+0x1.91fp+1')
+        testcommon("%x", -0.5, '-0x1p-1')
+        testcommon("%#x", -0.5, '-0x1.p-1')
+
         if verbose:
             print('Testing exceptions')
         test_exc_common('%', (), ValueError, "incomplete format")
@@ -279,9 +286,9 @@ def test_common_format(self):
         test_exc_common('%d', b'1', TypeError,
                         "%d format: a real number is required, not bytes")
         test_exc_common('%x', '1', TypeError,
-                        "%x format: an integer is required, not str")
-        test_exc_common('%x', 3.14, TypeError,
-                        "%x format: an integer is required, not float")
+                        "%x format: an integer or float is required, not str")
+        test_exc_common('%i', 1j, TypeError,
+                        "%i format: a real number is required, not complex")
 
     def test_str_format(self):
         testformat("%r", "\u0378", "'\\u0378'")  # non printable

Lib/test/test_peepholer.py

@@ -567,6 +567,7 @@ def format(fmt, *values):
         self.assertEqual(format('x = %s%% %%%%', 1234), 'x = 1234% %%')
         self.assertEqual(format('x = %s!', '%% %s'), 'x = %% %s!')
         self.assertEqual(format('x = %s, y = %d', 12, 34), 'x = 12, y = 34')
+        self.assertEqual(format('x = %x', 1234.56), 'x = 0x1.34a3d70a3d70ap+10')
 
     def test_format_errors(self):
         with self.assertRaisesRegex(TypeError,
@@ -586,9 +587,7 @@ def test_format_errors(self):
             eval("'%s%z' % (x, 5)", {'x': 1234})
         with self.assertRaisesRegex(TypeError, 'a real number is required, not str'):
             eval("'%d' % (x,)", {'x': '1234'})
-        with self.assertRaisesRegex(TypeError, 'an integer is required, not float'):
-            eval("'%x' % (x,)", {'x': 1234.56})
-        with self.assertRaisesRegex(TypeError, 'an integer is required, not str'):
+        with self.assertRaisesRegex(TypeError, 'an integer or float is required, not str'):
             eval("'%x' % (x,)", {'x': '1234'})
         with self.assertRaisesRegex(TypeError, 'must be real number, not str'):
             eval("'%f' % (x,)", {'x': '1234'})

Lib/test/test_str.py

@@ -1564,12 +1564,12 @@ def __int__(self):
         self.assertEqual('%X' % letter_m, '6D')
         self.assertEqual('%o' % letter_m, '155')
         self.assertEqual('%c' % letter_m, 'm')
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
+        self.assertEqual('%x' % 3.14, '0x1.91eb851eb851fp+1')
+        self.assertEqual('%X' % 2.11, '0X1.0E147AE147AE1P+1')
         self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
+        self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not PseudoFloat', operator.mod, '%x', pi)
+        self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not complex', operator.mod, '%x', 3j)
+        self.assertRaisesRegex(TypeError, '%X format: an integer or float is required, not complex', operator.mod, '%X', 2j)
         self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
         self.assertRaisesRegex(TypeError, '%u format: a real number is required, not complex', operator.mod, '%u', 3j)
         self.assertRaisesRegex(TypeError, '%i format: a real number is required, not complex', operator.mod, '%i', 2j)

Lib/test/test_types.py

@@ -525,8 +525,8 @@ def test(f, format_spec, result):
         self.assertRaises(TypeError, 3.0.__format__, None)
         self.assertRaises(TypeError, 3.0.__format__, 0)
 
-        # confirm format options expected to fail on floats, such as integer
-        # presentation types
+        # confirm format options expected to fail on floats, such as some
+        # integer presentation types
         for format_spec in 'sbcdo':
             self.assertRaises(ValueError, format, 0.0, format_spec)
             self.assertRaises(ValueError, format, 1.0, format_spec)

Objects/bytesobject.c

@@ -413,12 +413,15 @@ formatfloat(PyObject *v, int flags, int prec, int type,
         return NULL;
     }
 
-    if (prec < 0)
+    if (prec < 0 && type != 'x' && type != 'X')
         prec = 6;
 
     if (flags & F_ALT) {
         dtoa_flags |= Py_DTSF_ALT;
     }
+    if (flags & F_SIGN) {
+        dtoa_flags |= Py_DTSF_SIGN;
+    }
     p = PyOS_double_to_string(x, type, prec, dtoa_flags, NULL);
 
     if (p == NULL)
@@ -463,13 +466,30 @@ formatlong(PyObject *v, int flags, int prec, int type)
             Py_DECREF(iobj);
             return result;
         }
-        if (!PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            if (type == 'x' || type == 'X') {
+                PyErr_Clear();
+
+                PyObject *fobj = PyNumber_Float(v);
+                if (!fobj) {
+                    goto wrongtype;
+                }
+                formatfloat(fobj, flags, prec, type, &result, NULL, NULL);
+                if (!result) {
+                    return NULL;
+                }
+                return PyUnicode_FromEncodedObject(result, NULL, NULL);
+            }
+        }
+        else {
             return NULL;
+        }
     }
+  wrongtype:
     PyErr_Format(PyExc_TypeError,
         "%%%c format: %s is required, not %.200s", type,
-        (type == 'o' || type == 'x' || type == 'X') ? "an integer"
-                                                    : "a real number",
+        (type == 'x' || type == 'X') ?
+        "an integer or float" : type == 'o' ? "an integer": "a real number",
         Py_TYPE(v)->tp_name);
     return NULL;
 }

Objects/floatobject.c

@@ -1225,13 +1225,19 @@ static PyObject *
 float_hex_impl(PyObject *self)
 /*[clinic end generated code: output=0ebc9836e4d302d4 input=bec1271a33d47e67]*/
 {
-    double x;
-
-    CONVERT_TO_DOUBLE(self, x);
-
+    PyObject *result = NULL;
+    double x = PyFloat_AS_DOUBLE(self);
     char *buf = PyOS_double_to_string(x, 'x', -1, 0, NULL);
 
-    return PyUnicode_FromString(buf);
+    if (buf) {
+        result = PyUnicode_FromString(buf);
+        PyMem_Free(buf);
+    }
+    else {
+        PyErr_NoMemory();
+    }
+
+    return result;
 }
 
 /* Convert a hexadecimal string to a float. */

Objects/unicodeobject.c

@@ -13710,11 +13710,13 @@ formatfloat(PyObject *v, struct unicode_format_arg_t *arg,
         return -1;
 
     prec = arg->prec;
-    if (prec < 0)
+    if (prec < 0 && arg->ch != 'x' && arg->ch != 'X')
         prec = 6;
 
     if (arg->flags & F_ALT)
         dtoa_flags |= Py_DTSF_ALT;
+    if (arg->flags & F_SIGN)
+        dtoa_flags |= Py_DTSF_SIGN;
     p = PyOS_double_to_string(x, arg->ch, prec, dtoa_flags, NULL);
     if (p == NULL)
         return -1;
@@ -13902,11 +13904,12 @@ mainformatlong(PyObject *v,
             if (PyErr_ExceptionMatches(PyExc_TypeError)) {
                 if (type == 'x' || type == 'X') {
                     PyErr_Clear();
-                    if (PyFloat_Check(v)) {
-                        if (formatfloat(v, arg, NULL, writer) == -1)
-                            return -1;
-                        return 1;
+
+                    PyObject *fobj = PyNumber_Float(v);
+                    if (!fobj) {
+                        goto wrongtype;
                     }
+                    return formatfloat(fobj, arg, p_output, NULL);
                 }
                 goto wrongtype;
             }
@@ -13964,10 +13967,15 @@ mainformatlong(PyObject *v,
     switch(type)
     {
         case 'o':
+            PyErr_Format(PyExc_TypeError,
+                    "%%%c format: an integer is required, "
+                    "not %.200s",
+                    type, Py_TYPE(v)->tp_name);
+            break;
         case 'x':
         case 'X':
             PyErr_Format(PyExc_TypeError,
-                    "%%%c format: an integer is required, "
+                    "%%%c format: an integer or float is required, "
                     "not %.200s",
                     type, Py_TYPE(v)->tp_name);
             break;

Python/formatter_unicode.c

@@ -1282,7 +1282,7 @@ format_complex_internal(PyObject *value,
            format the result. We take care of that later. */
         type = 'g';
 
-    if (precision < 0 && (type != 'x' || type != 'X'))
+    if (precision < 0 && type != 'x' && type != 'X')
         precision = default_precision;
     else if (type == 'r')
         type = 'g';

Python/pystrtod.c

@@ -958,7 +958,7 @@ _Py_dg_dtoa_hex(double x, int precision, int always_add_sign,
     int e, shift, i, si;
     double m = frexp(fabs(x), &e);
 
-    if (m || e) {
+    if (m) {
         /* normalization XXX: valid after rounding? */
         shift = 1 - Py_MAX(DBL_MIN_EXP - e, 0);
         m = ldexp(m, shift);
@@ -1342,6 +1342,7 @@ char * PyOS_double_to_string(double val,
     /* Validate format_code, and map upper and lower case. Compute the
        mode and make any adjustments as needed. */
     switch (format_code) {
+    /* hexadecimal floats */
     case 'X':
         float_strings = uc_float_strings;
         /* Fall through. */