Longest possible %a string for floats and doubles?

Question

When using the %a specifier with the printf family of functions, what is the longest possible string that results for a float and for a double?

Assume that float and double are IEEE-754 32-bit and 64-bit floating points.

To be more specific, how large does buf need to be for the following functions so that buf does not get overrun (note that sprintf will also write a null-terminator):

#include <stdio.h>

void StringFromFloat(char *buf, float f) {
    sprintf(buf, "%a", f);
}

void StringFromDouble(char *buf, double d) {
    sprintf(buf, "%a", d);
}

I am assuming that %A has no difference in max length.

Answer 1

int main() {
    int c;
    printf("%a%n\n", -M_PI, &c);
    printf("%d\n", c+1);
    printf("%a%n\n", -DBL_MAX, &c);
    printf("%d\n", c+1);
    printf("%a%n\n", -DBL_MIN, &c);
    printf("%d\n", c+1);
}

emits

-0x1.921fb54442d18p+1
22
-0x1.fffffffffffffp+1023
25
-0x1p-1022
11

https://coliru.stacked-crooked.com/a/9c8e5f7a059b66a5

If we assume the format is standard, and that dobules are IEEE-754 64-bit, then the answer appears to be a length of 25 (including the trailing null)

The IEEE-754 64-bit type uses a sign bit (1 character), a 52-bit mantissa (13 hex characters), and a 11-bit exponent (5 hex characters). That matches our results above (-, fffffffffffff, and +1023), which implies that the other 6 bytes are ~standard formatting (0x1., p, and '\0')

Answer 2

what is the longest possible string
how large does buf need to be

Usual a string is assessed in length and the buffer size needed is 1 more than the length. The maximum length is discussed below. Add one for the size.

---

"%a" has various implementation defined details. Because of that, code should be very careful about assuming the maximum length based on some calculation as below. Prudent code would handle a few extra characters.

Reasonable estimate: the sum of:

• longest significand length, perhaps of the form -1.xxx...xxx where x is a hexadecimal digit. Assuming FLT_RADIX==2: 1 /* sign */ + 2 /* 0x */ + 1 /* lead digit */ + 1 /* . */ + roundup((xxx_MANT_DIG-1)/4).

• longest exponent which is a decimal power-of-2 for the value xxx_TRUE_MIN or 1 /* p */ + 1 /* sign */ + roundup(log2(-xxx_MIN_EXP + xxx_MANT_DIG)).

---

For common double:

significand length: `1 + 2 + 1 + 1 + ru((53-1)/4)` --> 18

exponent length: `1 + 1 + ru(log10(- -1021 + 53))` --> 6

sum: 24

---

For common float:

significand length: `1 + 2 + 1 + 1 + ru((24-1)/4)` --> 11

exponent length: `1 + 1 + ru(log10(- -125 + 24))` --> 5

sum: 16

---

Consider NANs may have payload formatted in some interesting fashion that exceeds the above sums.

Example: double NAN w/payload: "-NAN4503599627370495". C specifies the payload and characters:[0-9A-Za-z_], but is silent on its length. One implementation used the payload as a decimal value.

1 /* sign */ + 3 /* NAN */ + 16 /* decimal digits = 20

A 52-bit payload reasonable is expected to have no more than 52 payload characters. I have never seen one longer than the above 20.

1 /* sign */ + 3 /* NAN */ + 52 /* binary digits = 56

---

C spec about "%a", "%A":

A double argument representing a floating-point number is converted in the style [-]0xh.hhhhp±d, where there is one hexadecimal digit (which is nonzero if the argument is a normalized floating-point number and is otherwise unspecified) before the decimal-point character) and the number of hexadecimal digits after it is equal to the precision; if the precision is missing and FLT_RADIX is a power of 2, then the precision is sufficient for an exact representation of the value; if the precision is missing and FLT_RADIX is not a power of 2, then the precision is sufficient to distinguish values of type double, except that trailing zeros may be omitted; if the precision is zero and the # flag is not specified, no decimal-point character appears. The letters abcdef are used for a conversion and the letters ABCDEF for A conversion. The A conversion specifier produces a number with X and P instead of x and p. The exponent always contains at least one digit, and only as many more digits as necessary to represent the decimal exponent of 2. If the value is zero, the exponent is zero.
A double argument representing an infinity or NaN is converted in the style of an f or F conversion specifier.
C17dr § 7.21.6.1 8

Answer 3

How large does buf need to be for the following functions so that buf does not get overrun?

Consider instead of trying to find the smallest maximum buffer size, pass the size into the function and let snprintf() prevent any buffer overrun. @Andrew Henle

void StringFromFloat(size_t sz, char *buf, float f) {
  volatile int len = snprintf(buf, sz, "%a", f);
  assert(len >= 0 && (unsigned) len < sz);
}

If the calling code wants to pass in what is thought to be buffer size that always works, compute the expected max size with various macros.
For LOG10_PR(), see this for more ideas.

#include <float.h>
#define LOG10_PR(x) (1 + (x)>9 + (x)>99 + (x)>999 + (x)>9999 + (x)>99999) 
#define PRINTF_A_SIZE_FLT ( \
    5 /* -0x1. */ + (FLT_MANT_DIG-1+3)/4 + \
    2 /* p- */ + LOG10_PR(FLT_MANT_DIG - FLT_MIN_EXP) + \
    1 /* \0 */)

char buf[PRINTF_A_SIZE_FLT];
StringFromFloat(sizeof buf, buf, some_float);

Or instead, be generous and use the bit width of the object to scale the buffer size if a few extra bytes is not a concern.

char buf[sizeof some_float * CHAR_BIT + 1];
StringFromFloat(sizeof buf, buf, some_float);