gh-113804: Support "x" and "X" format types for floats

_Py_dg_dtoa_hex() is based on float.hex() with additional support for
the precision setting and some format flags.

Examples:
```pycon
>>> f'{-0.1:x}'
'-0x1.999999999999ap-4'
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> f'{3.14159:+X}'
'+0X1.921F9F01B866EP+1'
>>> f'{3.14159:.3x}'
'0x1.922p+1'
```

Author: skirpichev

Doc/library/string.rst

@@ -588,6 +588,30 @@ The available presentation types for :class:`float` and
    |         | as altered by the other format modifiers.                |
    +---------+----------------------------------------------------------+
 
+Additionally, for :class:`float` available following representation types:
+
+   +---------+----------------------------------------------------------+
+   | Type    | Meaning                                                  |
+   +=========+==========================================================+
+   | ``'x'`` | Represent the number by a hexadecimal string in the      |
+   |         | style ``[±]0xh.hhhhp±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 ``'#'``     |
+   |         | option 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.         |
+   +---------+----------------------------------------------------------+
+   | ``'X'`` | Same as ``'x'``, but uses ``0X`` prefix and ``'P'`` as   |
+   |         | the exponent separator.                                  |
+   +---------+----------------------------------------------------------+
+
+.. versionchanged:: 3.13
+   Support ``'x'`` and ``'X'`` format types for :class:`float`.
+
 
 .. _formatexamples:
 

Lib/test/test_complex.py

@@ -814,7 +814,7 @@ def test_format(self):
         self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
 
         # integer presentation types are an error
-        for t in 'bcdoxX':
+        for t in 'bcdo':
             self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
 
         # make sure everything works in ''.format()

Lib/test/test_float.py

@@ -705,7 +705,7 @@ def test_format(self):
 
         # confirm format options expected to fail on floats, such as integer
         # presentation types
-        for format_spec in 'sbcdoxX':
+        for format_spec in 'sbcdo':
             self.assertRaises(ValueError, format, 0.0, format_spec)
             self.assertRaises(ValueError, format, 1.0, format_spec)
             self.assertRaises(ValueError, format, -1.0, format_spec)

Lib/test/test_random.py

@@ -599,16 +599,16 @@ def test_guaranteed_stable(self):
              '0x1.1ebb4352e4c4dp-1', '0x1.1a7422abf9c11p-1'])
         self.gen.seed("the quick brown fox", version=2)
         self.assertEqual([self.gen.random().hex() for i in range(4)],
-            ['0x1.1239ddfb11b7cp-3', '0x1.b3cbb5c51b120p-4',
+            ['0x1.1239ddfb11b7cp-3', '0x1.b3cbb5c51b12p-4',
              '0x1.8c4f55116b60fp-1', '0x1.63eb525174a27p-1'])
 
     def test_bug_27706(self):
         # Verify that version 1 seeds are unaffected by hash randomization
 
         self.gen.seed('nofar', version=1)   # hash('nofar') == 5990528763808513177
         self.assertEqual([self.gen.random().hex() for i in range(4)],
-            ['0x1.8645314505ad7p-1', '0x1.afb1f82e40a40p-5',
-             '0x1.2a59d2285e971p-1', '0x1.56977142a7880p-6'])
+            ['0x1.8645314505ad7p-1', '0x1.afb1f82e40a4p-5',
+             '0x1.2a59d2285e971p-1', '0x1.56977142a788p-6'])
 
         self.gen.seed('rachel', version=1)  # hash('rachel') == -9091735575445484789
         self.assertEqual([self.gen.random().hex() for i in range(4)],
@@ -639,8 +639,8 @@ def test_bug_31482(self):
 
         self.gen.seed(b'nofar', version=1)   # hash('nofar') == 5990528763808513177
         self.assertEqual([self.gen.random().hex() for i in range(4)],
-            ['0x1.8645314505ad7p-1', '0x1.afb1f82e40a40p-5',
-             '0x1.2a59d2285e971p-1', '0x1.56977142a7880p-6'])
+            ['0x1.8645314505ad7p-1', '0x1.afb1f82e40a4p-5',
+             '0x1.2a59d2285e971p-1', '0x1.56977142a788p-6'])
 
         self.gen.seed(b'rachel', version=1)  # hash('rachel') == -9091735575445484789
         self.assertEqual([self.gen.random().hex() for i in range(4)],

Lib/test/test_str.py

@@ -1321,10 +1321,6 @@ def __repr__(self):
         self.assertRaises(ValueError, ("{[" + big + "]}").format, [0])
 
         # test number formatter errors:
-        self.assertRaises(ValueError, '{0:x}'.format, 1j)
-        self.assertRaises(ValueError, '{0:x}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:X}'.format, 1j)
-        self.assertRaises(ValueError, '{0:X}'.format, 1.0)
         self.assertRaises(ValueError, '{0:o}'.format, 1j)
         self.assertRaises(ValueError, '{0:o}'.format, 1.0)
         self.assertRaises(ValueError, '{0:u}'.format, 1j)

Lib/test/test_strtod.py

@@ -2,8 +2,8 @@
 # introduced in Python 2.7 and 3.1.
 
 import random
-import unittest
 import re
+import unittest
 import sys
 import test.support
 
@@ -98,7 +98,7 @@ def check_strtod(self, s):
             got = 'memory error'
         else:
             got = fs.hex()
-        expected = strtod(s)
+        expected = re.sub(r'\.?0+p', 'p', strtod(s))
         self.assertEqual(expected, got,
                          "Incorrectly rounded str->float conversion for {}: "
                          "expected {}, got {}".format(s, expected, got))

Lib/test/test_types.py

@@ -527,7 +527,7 @@ def test(f, format_spec, result):
 
         # confirm format options expected to fail on floats, such as integer
         # presentation types
-        for format_spec in 'sbcdoxX':
+        for format_spec in 'sbcdo':
             self.assertRaises(ValueError, format, 0.0, format_spec)
             self.assertRaises(ValueError, format, 1.0, format_spec)
             self.assertRaises(ValueError, format, -1.0, format_spec)

Misc/NEWS.d/next/Library/2024-01-08-08-00-14.gh-issue-113804.1nizF2.rst

@@ -0,0 +1 @@
+Support "x" and "X" format types for floats.  Patch by Sergey B Kirpichev.

Objects/floatobject.c

@@ -1141,14 +1141,7 @@ float_conjugate_impl(PyObject *self)
     return float_float(self);
 }
 
-/* turn ASCII hex characters into integer values and vice versa */
-
-static char
-char_from_hex(int x)
-{
-    assert(0 <= x && x < 16);
-    return Py_hexdigits[x];
-}
+/* turn ASCII hex characters into integer values */
 
 static int
 hex_from_char(char c) {
@@ -1217,10 +1210,6 @@ hex_from_char(char c) {
 
 /* convert a float to a hexadecimal string */
 
-/* TOHEX_NBITS is DBL_MANT_DIG rounded up to the next integer
-   of the form 4k+1. */
-#define TOHEX_NBITS DBL_MANT_DIG + 3 - (DBL_MANT_DIG+2)%4
-
 /*[clinic input]
 float.hex
 
@@ -1236,54 +1225,13 @@ static PyObject *
 float_hex_impl(PyObject *self)
 /*[clinic end generated code: output=0ebc9836e4d302d4 input=bec1271a33d47e67]*/
 {
-    double x, m;
-    int e, shift, i, si, esign;
-    /* Space for 1+(TOHEX_NBITS-1)/4 digits, a decimal point, and the
-       trailing NUL byte. */
-    char s[(TOHEX_NBITS-1)/4+3];
+    double x;
 
     CONVERT_TO_DOUBLE(self, x);
 
-    if (Py_IS_NAN(x) || Py_IS_INFINITY(x))
-        return float_repr((PyFloatObject *)self);
-
-    if (x == 0.0) {
-        if (copysign(1.0, x) == -1.0)
-            return PyUnicode_FromString("-0x0.0p+0");
-        else
-            return PyUnicode_FromString("0x0.0p+0");
-    }
-
-    m = frexp(fabs(x), &e);
-    shift = 1 - Py_MAX(DBL_MIN_EXP - e, 0);
-    m = ldexp(m, shift);
-    e -= shift;
-
-    si = 0;
-    s[si] = char_from_hex((int)m);
-    si++;
-    m -= (int)m;
-    s[si] = '.';
-    si++;
-    for (i=0; i < (TOHEX_NBITS-1)/4; i++) {
-        m *= 16.0;
-        s[si] = char_from_hex((int)m);
-        si++;
-        m -= (int)m;
-    }
-    s[si] = '\0';
-
-    if (e < 0) {
-        esign = (int)'-';
-        e = -e;
-    }
-    else
-        esign = (int)'+';
+    char *buf = PyOS_double_to_string(x, 'x', -1, 0, NULL);
 
-    if (x < 0.0)
-        return PyUnicode_FromFormat("-0x%sp%c%d", s, esign, e);
-    else
-        return PyUnicode_FromFormat("0x%sp%c%d", s, esign, e);
+    return PyUnicode_FromString(buf);
 }
 
 /* Convert a hexadecimal string to a float. */

Python/formatter_unicode.c

@@ -1100,7 +1100,7 @@ format_float_internal(PyObject *value,
         add_pct = 1;
     }
 
-    if (precision < 0)
+    if (precision < 0 && type != 'x' && type != 'X')
         precision = default_precision;
     else if (type == 'r')
         type = 'g';
@@ -1282,7 +1282,7 @@ format_complex_internal(PyObject *value,
            format the result. We take care of that later. */
         type = 'g';
 
-    if (precision < 0)
+    if (precision < 0 && (type != 'x' || type != 'X'))
         precision = default_precision;
     else if (type == 'r')
         type = 'g';
@@ -1574,6 +1574,8 @@ _PyFloat_FormatAdvancedWriter(_PyUnicodeWriter *writer,
     case 'G':
     case 'n':
     case '%':
+    case 'x':
+    case 'X':
         /* no conversion, already a float.  do the formatting */
         return format_float_internal(obj, &format, writer);
 
@@ -1612,6 +1614,8 @@ _PyComplex_FormatAdvancedWriter(_PyUnicodeWriter *writer,
     case 'g':
     case 'G':
     case 'n':
+    case 'x':
+    case 'X':
         /* no conversion, already a complex.  do the formatting */
         return format_complex_internal(obj, &format, writer);