xjb: Fast Float to String Algorithm

1. Introduction

Floating-point to decimal string conversion is a fundamental operation in computer systems with widespread applications across numerous domains. From scientific computing and financial systems to web services and database management, the ability to efficiently and accurately convert binary floating-point representations into human-readable decimal strings is essential. Despite its apparent simplicity, this conversion problem presents significant challenges in balancing the competing demands of correctness, performance, and output compactness.

1.1. Background and Motivation

In 1990, Steele and White [1,2] published the seminal paper How to Print Floating-Point Numbers Accurately, which established the foundational principles for optimal floating-point printing algorithms, now widely known as the Steele-White (SW) principle. The SW principle comprises four key requirements:

• Information preservation: The printed result must be parseable back to the original floating-point number without loss of precision.
• Minimum length: The output string should be as short as possible while maintaining information preservation.
• Correct rounding: When multiple representations satisfy the first two criteria, the algorithm must correctly round to the nearest value, with ties broken by selecting the even value.
• Left-to-right generation: The output digits should be generated sequentially from the most significant to the least significant digit.

These principles ensure that floating-point numbers have a unique, well-defined decimal representation that is both human-readable and machine-parseable. Algorithms satisfying the SW principle guarantee that the conversion process is reversible and produces the shortest possible output, which is crucial for data exchange, serialization, and user interface display.

Over the past three decades, significant research efforts have been devoted to developing efficient algorithms that satisfy the SW principle. Early approaches, such as the Dragon4 algorithm, provided correct results but suffered from performance limitations due to the use of arbitrary-precision arithmetic. Subsequent innovations introduced various optimizations:

• dtoa.c [3] is an improved version of Dragon4, written by Robert G. Burger and R. Kent Dybvig in 1996. The source code link is https://www.netlib.org/fp/dtoa.c.
• Grisu3 [4] pioneered the use of precomputed powers of ten to avoid expensive arbitrary-precision operations, though it occasionally falls back to slower methods for certain inputs.
• Errol [5] improved upon Grisu3 by reducing the fallback rate through more precise error analysis.
• Ry$\overline{\mathrm{u}}$ [6,7] achieved significant performance gains through careful instruction scheduling and lookup table optimizations, establishing a new baseline for high-performance conversion.
• Schubfach [8] introduced a novel approach based on the concept of "Schubfach" (pigeonhole principle), providing a compact and elegant solution with competitive performance.
• Grisu-Exact [9] eliminated the need for fallbacks entirely while maintaining high performance.
• Dragonbox [10] reduces the number of multiplications by sacrificing more branches.
• yy_double [11] explored alternative computational strategies to minimize the multiplication cost, but there were still a few branches.
• uscale [12,13,14] was proposed by Russ Cox and is used to enhance the performance of the floating-point number printing algorithm in the Go programming language.
• zmij [15] is based on yy_double and has undergone extensive code optimization.

Despite these advances, existing algorithms still face several performance challenges that limit their effectiveness in high-throughput scenarios:

1.

Branch prediction penalties: Many algorithms rely heavily on conditional branches to handle different cases, leading to frequent branch mispredictions on modern pipelined processors.

2.

High-precision multiplication overhead: The conversion process requires high-precision arithmetic operations, particularly multiplications involving large precomputed constants, which can be expensive on standard hardware.

3.

Instruction dependency chains: Sequential dependencies between operations limit instruction-level parallelism and prevent efficient utilization of modern superscalar processors.

4.

Limited SIMD utilization: Most existing algorithms do not exploit vector instruction sets (SIMD) that are now ubiquitous in contemporary processors.

These limitations motivate the need for a new approach that addresses these performance bottlenecks while maintaining full compliance with the SW principle.

1.2. Contributions

This paper presents xjb, a novel floating-point to string conversion algorithm that achieves superior performance through systematic optimization of the underlying computational structure. The xjb algorithm is derived from the Schubfach algorithm and incorporates insights from yy_double and Dragonbox, but introduces several key innovations:

1.

Reduced instruction dependencies: By carefully restructuring the computation, xjb minimizes data dependencies between operations, enabling better instruction-level parallelism and improved pipeline utilization.

2.

Minimized multiplication operations: The algorithm reduces the number of expensive high-precision multiplications required during conversion, significantly decreasing computational overhead.

3.

Mitigated branch prediction penalties: Through branchless programming techniques and careful case analysis, xjb minimizes conditional branches that could lead to prediction failures.

4.

SIMD instruction utilization: The algorithm is designed to leverage SIMD instructions where applicable.

5.

Concise core implementation: Despite its sophisticated optimizations, xjb maintains a compact and readable core implementation, facilitating adoption and maintenance.

The xjb algorithm supports both IEEE 754 single-precision (binary32) and double-precision (binary64) floating-point formats, which are the most widely used floating-point representations in modern computing. For simplicity, this paper uses float to refer to IEEE 754 binary32 and double to refer to IEEE 754 binary64.

1.3. Evaluation Overview

We conducted extensive benchmarking of xjb across diverse hardware platforms, including AMD R7-7840H and Apple M1 processors. Our evaluation demonstrates that xjb outperforms state-of-the-art algorithms in most scenarios while maintaining full compliance with the SW principle. The algorithm exhibits excellent portability and scalability, making it suitable for deployment across a wide range of systems from embedded devices to high-performance servers.

The implementation code for the xjb algorithm and all benchmark tools used in this paper are available at https://github.com/xjb714/xjb.

The remainder of this paper is organized as follows. Section 2 reviews the IEEE 754 floating-point representation and establishes the mathematical foundation for the conversion problem. Section 3 presents the core principles and derivation of the xjb algorithm and describes the implementation details and optimizations. Section 4 presents experimental results comparing xjb against existing algorithms.

1.4. Explanation of Special Symbols in This Article

Provide special explanations for the special symbols used in the formulas of this article.

Table 1. Explanation of Special Symbols in This Article.

symbol	brief explanation	example
%	Integer modulus operation	2 = 8%3
//	Integer division operation	1 = 5//3
$<<$ or $>>$	Left or right shift of binary values	8 = 1$<<$3
? :	Similar to the ternary operator in C syntax	a = 1?a:b

Table 1. Explanation of Special Symbols in This Article.

symbol	brief explanation	example
%	Integer modulus operation	2 = 8%3
//	Integer division operation	1 = 5//3
$<<$ or $>>$	Left or right shift of binary values	8 = 1$<<$3
? :	Similar to the ternary operator in C syntax	a = 1?a:b

2. IEEE754 Floating-Point Number Representation

This section establishes the mathematical foundation for floating-point number representation and defines the notation used throughout this paper. We focus on the IEEE 754 standard, which is the most widely adopted floating-point arithmetic standard in modern computing systems.

2.1. Scope and Assumptions

For clarity of presentation, we make the following simplifying assumptions:

• We consider only positive floating-point numbers, as negative numbers differ only by a leading minus sign.
• We exclude special values (zero, NaN, and infinity) from our analysis, as these are handled separately in practice.

These assumptions are standard in the literature and do not affect the generality of our algorithm, as the excluded cases can be handled with straightforward special-case logic.

2.2. Binary Representation

The IEEE 754 standard [16,17] defines two primary floating-point formats relevant to this work:

Double-precision (binary64): A 64-bit format consisting of:

• 1 sign bit (s): indicates positive ($s=0$) or negative ($s=1$).
• 11 exponent bits (e): biased exponent in the range $[0,2047]$.
• 52 fraction bits (f): significand fraction in the range $[0,2^{52}-1]$.

Single-precision (binary32): A 32-bit format consisting of:

• 1 sign bit (s): indicates positive ($s=0$) or negative ($s=1$).
• 8 exponent bits (e): biased exponent in the range $[0,255]$.
• 23 fraction bits (f): significand fraction in the range $[0,2^{23}-1]$.

2.3. Classification of Floating-Point Numbers

We classify floating-point numbers into three categories based on their exponent and fraction fields:

1.

Subnormal numbers ($e=0$ and $f\ne 0$): These represent very small values close to zero, where the implicit leading bit of the significand is 0 instead of 1.

2.

Normal numbers ($e\ne 0$ and $f\ne 0$): The standard case where the implicit leading bit of the significand is 1.

3.

Irregular numbers ($e\ne 0$ and $f=0$): Numbers with zero fraction field, representing powers of two.

We use the term regular to refer to both subnormal and normal numbers (i.e., all cases where $f\ne 0$).

2.4. Value Representation

The real value v of a positive floating-point number can be expressed in the unified form $v=c·2^q$, where c is the integer significand and q is the exponent. The general formula covering all cases is:

$$\begin{array}{cc}\hfill \mathrm{double}:& v=\left(f+(e\ne 0?2^{52}:0)\right)·2^{max(e,1)-1075}=c·2^q\hfill \\ \hfill \mathrm{float}:& v=\left(f+(e\ne 0?2^{23}:0)\right)·2^{max(e,1)-150}=c·2^q\hfill \end{array}$$

(1)

For each category, the values decompose as follows:

Subnormal numbers ($e=0$):

$$\begin{array}{c}\hfill \mathrm{subnormal}:\left\{\begin{array}{cc}\mathrm{double}:\hfill & v=f·2^{-1074}\hfill \\ \mathrm{float}:\hfill & v=f·2^{-149}\hfill \end{array}\right.\end{array}$$

(2)

Irregular numbers ($f=0$, $e\ne 0$):

$$\begin{array}{c}\hfill \mathrm{irregular}:\left\{\begin{array}{cc}\mathrm{double}:\hfill & v=2^{52}·2^{e-1075}\hfill \\ \mathrm{float}:\hfill & v=2^{23}·2^{e-150}\hfill \end{array}\right.\end{array}$$

(3)

Normal numbers ($e\ne 0$, $f\ne 0$):

$$\begin{array}{c}\hfill \mathrm{normal}:\left\{\begin{array}{cc}\mathrm{double}:\hfill & v=(f+2^{52})·2^{e-1075}\hfill \\ \mathrm{float}:\hfill & v=(f+2^{23})·2^{e-150}\hfill \end{array}\right.\end{array}$$

(4)

2.5. Rounding Intervals

A critical concept for accurate floating-point printing is the rounding interval $R_v$, which defines the range of real numbers that round to the given floating-point value v when parsed. The rounding interval is bounded by:

$$\begin{array}{cc}\hfill v_l& =\left\{\begin{array}{cc}\left(c-{\displaystyle \frac{1}{2}}\right)·2^q\hfill & \mathrm{if}f\ne 0\mathrm{or}e\le 1\hfill \\ \left(c-{\displaystyle \frac{1}{4}}\right)·2^q\hfill & \mathrm{if}f=0\hfill \end{array}\right.\hfill \\ \hfill v_r& =\left(c+{\displaystyle \frac{1}{2}}\right)·2^q\hfill \\ \hfill R_v& =\left\{\begin{array}{cc}[v_l,v_r]\hfill & \mathrm{if}fmod2=0(\mathrm{even}\mathrm{significand})\hfill \\ (v_l,v_r)\hfill & \mathrm{if}fmod2=1(\mathrm{odd}\mathrm{significand})\hfill \end{array}\right.\hfill \end{array}$$

(5)

The rounding radius for regular floating-point numbers is $2^{q-1}$. The distinction between closed and open intervals at the boundaries depends on the parity of the significand, ensuring correct rounding according to the round-to-even rule specified in the IEEE 754 standard. Any decimal number within $R_v$ will parse back to the original floating-point value v, which is essential for ensuring the information preservation property of the SW principle.

Table 2 summarizes the valid ranges for c and q across different categories.

3. Principle of Algorithm

This section presents the algorithmic principles and mathematical foundation of the xjb floating-point to string conversion algorithm. We first introduce the overall architecture and design goals, followed by the mathematical formulation of the conversion problem.

3.1. Design Overview

This paper focuses on converting float (single-precision) and double (double-precision) floating-point numbers to decimal strings. The conversion process consists of two stages:

1.

Float-to-Decimal Conversion: Converting binary floating-point values to decimal significand-exponent pairs $(d,k)$.

2.

Decimal-to-String Conversion: Formatting $(d,k)$ into human-readable strings.

We focus primarily on the first stage, as it is the computationally intensive component that benefits most from our optimizations.

The xjb algorithm is designed with four key performance objectives:

• Minimize branch mispredictions through unlikely branches and branchless techniques
• Reduce expensive high-precision multiplication operations
• Optimize instruction dependencies to enable better parallelism
• Maintain core implementation simplicity and readability

3.2. Mathematical Foundation

Before presenting the algorithm details, we establish the mathematical framework for the float-to-decimal conversion problem.

Recall from Section 2 that any floating-point value v can be expressed in the form $v=c·2^q$, where c is the integer significand and q is the exponent. Our goal is to find the optimal decimal representation $opt=d·{10}^k$ that satisfies the SW principle.

As established in Section 2, regular floating-point numbers (which include all normal and subnormal numbers with non-zero fraction fields) account for the vast majority of possible floating-point values. For the purposes of algorithm derivation, we focus primarily on regular numbers, as special cases can be handled with minimal additional logic.

The valid ranges for the significand c and exponent q for regular floating-point numbers are:

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{cc}1\le c\le 2^{24}-1,c\ne 2^{23},\hfill & q=-149\hfill \\ 2^{23}+1\le c\le 2^{24}-1,\hfill & -148\le q\le 104\hfill \end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{cc}1\le c\le 2^{53}-1,c\ne 2^{52},\hfill & q=-1074\hfill \\ 2^{52}+1\le c\le 2^{53}-1,\hfill & -1073\le q\le 971\hfill \end{array}\right.\hfill \end{array}$$

(6)

For irregular floating-point numbers (powers of two), the ranges are:

$$\begin{array}{cc}\hfill \mathrm{float}:& c=2^{23},-149\le q\le 104\hfill \\ \hfill \mathrm{double}:& c=2^{52},-1074\le q\le 971\hfill \end{array}$$

(7)

For subnormal numbers:

$$\begin{array}{cc}\hfill \mathrm{float}:& c\le 2^{23}-1,q=-149\hfill \\ \hfill \mathrm{double}:& c\le 2^{52}-1,q=-1074\hfill \end{array}$$

(8)

The conversion problem can now be formally stated as: given a floating-point value $v=c·2^q$, find the optimal decimal representation $opt=d·{10}^k$ such that:

$$\begin{array}{cc}\hfill v=c·2^q& \to opt=d·{10}^k\hfill \\ \hfill \mathrm{subject}\mathrm{to}\text{:}& opt\in R_v,d\in {\mathbb{Z}}^{+},k\in \mathbb{Z}\hfill \end{array}$$

(9)

where $R_v$ is the rounding interval of v as defined in Section 2.

For example, consider the IEEE 754 binary64 floating-point number representing 1.3. Its actual value is 1.3000000000000000444089209850062616169452667236328125, with hexadecimal representation 3ff4cccccccccccd. The optimal decimal representation $opt$ satisfying the SW principle is simply 1.3. Similarly, for the binary32 representation of 1.3, with actual value 1.2999999523162841796875 and hexadecimal representation 3fa66666, the optimal representation is also 1.3.

3.3. Review of the Schubfach Algorithm and Our Derivation

This section reviews the Schubfach algorithm and presents our derivation of an optimized variant. We begin by establishing the mathematical foundation for determining the optimal decimal representation.

3.3.1. Candidate Values for the Significand d

The Schubfach algorithm identifies four candidate values for the decimal significand d:

$$\begin{array}{c}\hfill d\in \{10\lfloor v·{10}^{-k-1}\rfloor ,\lfloor 10v·{10}^{-k-1}\rfloor ,\lfloor 10v·{10}^{-k-1}\rfloor +1,10\lfloor v·{10}^{-k-1}\rfloor +10\}\end{array}$$

(10)

The exponent k is computed as:

$$k=\left\{\begin{array}{cc}\lfloor q·lg2\rfloor \hfill & \mathrm{if}v\in \mathrm{regular}\hfill \\ \lfloor q·lg2-lg(4/3)\rfloor \hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(11)

For efficient computation on modern processors, Equation (11) can be implemented using integer arithmetic:

$$\begin{array}{cc}\hfill \mathrm{double}:k& =(q·315653-(v\in \mathrm{regular}?0:131072\left)\right)\gg 20\hfill \\ \hfill \mathrm{float}:k& =(q·1233-(v\in \mathrm{regular}?0:512\left)\right)\gg 12\hfill \end{array}$$

(12)

3.3.2. Decomposition into Integer and Fractional Parts

Let $m=\lfloor v·{10}^{-k-1}\rfloor$ denote the integer part and $n=v·{10}^{-k-1}-m$ the fractional part, where $0\le n<1$. Substituting into Equation (10):

$$d\in \{10m,\lfloor 10(m+n)\rfloor ,\lfloor 10(m+n)\rfloor +1,10m+10\}$$

(13)

Since $\lfloor 10(m+n)\rfloor =10m+\lfloor 10n\rfloor$, the candidates simplify to:

$$d\in \{10m,10m+\lfloor 10n\rfloor ,10m+\lfloor 10n\rfloor +1,10m+10\}$$

(14)

Based on the Schubfach algorithm and the SW principle, if the value $10m$ or $10m+10$ falls within the range $R_v$, it is selected as the optimal solution d. In cases where neither $10m$ nor $10m+10$ lies within $R_v$, the optimal solution d is determined as either $10m+\lfloor 10n\rfloor$ or $10m+\lfloor 10n\rfloor +1$ in accordance with the rules of correct rounding. We decompose d as $d=ten+one$, where $ten=10m$ and $one\in \{0,\lfloor 10n\rfloor ,\lfloor 10n\rfloor +1,10\}$. The problem thus reduces to determining the appropriate value of $one$.

$$one=\left\{\begin{array}{c}0;\mathrm{if}10m\in R_v\\ 10;\mathrm{else}\mathrm{if}10m+10\in R_v\\ \lfloor 10n\rfloor \mathrm{or}\lfloor 10n\rfloor +1;\mathrm{else}\mathrm{apply}\mathrm{correct}\mathrm{rounding}\end{array}\right.$$

(15)

3.3.3. Selection Criteria for $One$

The selection of $one$ depends on the relationship between the rounding interval and the candidate values. Recall that the rounding interval for a regular floating-point number $v=c·2^q$ is $R_v=[v-2^{q-1},v+2^{q-1}]$, where $2^{q-1}$ represents the half-unit in the last place (ulp) of v.

• Case $one=0$ (i.e., $d=10m$): This case applies when $10m·{10}^k$ is the closest representable decimal to v within the rounding interval. The condition is derived as follows:
  The lower bound of the rounding interval must be less than $10m·{10}^k$:

  $$\begin{array}{cc}\hfill c·2^q-10m·{10}^k& <2^{q-1}\hfill \\ \hfill c·2^q-\lfloor c·2^q·{10}^{-k-1}\rfloor ·{10}^{k+1}& <2^{q-1}\hfill \\ \hfill c·2^q·{10}^{-k-1}-\lfloor c·2^q·{10}^{-k-1}\rfloor & <2^{-1}·2^q·{10}^{-k-1}\hfill \\ \hfill n& <2^{q-1}·{10}^{-k-1}\hfill \end{array}$$

  (16)
  When equality holds ($n=2^{q-1}·{10}^{-k-1}$), we apply the round-to-even rule, requiring c to be even:

  $$one=0\mathrm{if}{2}^{q-1}·{10}^{-k-1}>n\mathrm{or}\left(2^{q-1}·{10}^{-k-1}=n\mathrm{and}cmod2=0\right)$$

  (17)
• Case $one=10$ (i.e., $d=10m+10$): This case applies when $(10m+10)·{10}^k$ is the closest representable decimal to v. The condition is derived similarly:
  The upper bound of the rounding interval must be greater than $(10m+10)·{10}^k$:

  $$\begin{array}{cc}\hfill (10m+10)·{10}^k-c·2^q& <2^{q-1}\hfill \\ \hfill \lfloor c·2^q·{10}^{-k-1}\rfloor ·{10}^{k+1}+{10}^{k+1}-c·2^q& <2^{q-1}\hfill \\ \hfill 1-\left(c·2^q·{10}^{-k-1}-\lfloor c·2^q·{10}^{-k-1}\rfloor \right)& <2^{-1}·2^q·{10}^{-k-1}\hfill \\ \hfill 1-n& <2^{q-1}·{10}^{-k-1}\hfill \end{array}$$

  (18)
  When equality holds ($1-n=2^{q-1}·{10}^{-k-1}$), we again apply round-to-even:

  $$one=10\mathrm{if}{2}^{q-1}·{10}^{-k-1}>1-n\mathrm{or}\left(2^{q-1}·{10}^{-k-1}=1-n\mathrm{and}cmod2=0\right)$$

  (19)
• Case $one\in \{\lfloor 10n\rfloor ,\lfloor 10n\rfloor +1\}$: When neither boundary condition applies, the optimal value lies between $10m+\lfloor 10n\rfloor$ and $10m+\lfloor 10n\rfloor +1$. We determine $one$ by rounding $10n$ to the nearest integer:

  –

  If the fractional part $\left\{10n\right\}<0.5$: $one=\lfloor 10n\rfloor$

  –

  If the fractional part $\left\{10n\right\}>0.5$: $one=\lfloor 10n\rfloor +1$

  –

  If the fractional part $\left\{10n\right\}=0.5$: apply round-to-even

  For irregular floating-point numbers (powers of two), additional verification is required to ensure the selected value lies within the rounding interval $R_v$, as the interval boundaries differ for these special cases.

3.3.4. Algorithm Overview

Algorithm 1 summarizes our optimized variant of the Schubfach algorithm (xjb32 for float, xjb64 for double). Given inputs c and q, the algorithm returns d and k such that $d·{10}^k$ satisfies the SW principle. The computation of k follows Equation (12); the remainder of this section focuses on efficient computation of d.

The subsequent sections detail:

1.

Lookup table precomputation

2.

Efficient computation of m

3.

Fast boundary condition testing for $one\in \{0,10\}$

4.

Efficient computation of $\lfloor 10n\rfloor$ and rounding

5.

Handling of irregular floating-point numbers

6.

implementation of pseudocode

The following will discuss the above content in detail from Section 3.4 to Section 3.9.

Algorithm 1:The xjb Algorithm for Float-to-Decimal Conversion

Require:  Floating-point components c (significand) and q (exponent) Ensure:  Decimal representation $d·{10}^k$ satisfying the SW principle 1: $c·2^q\leftarrow v$ 2: if$v\in \mathrm{regular}$then 3:    $k\leftarrow \lfloor q·lg2\rfloor$ 4: else 5:    $k\leftarrow \lfloor q·lg2-lg(4/3)\rfloor$ 6: end if 7: $m\leftarrow \lfloor v·{10}^{-k-1}\rfloor$ 8: $n\leftarrow v·{10}^{-k-1}-m$ 9: $ten\leftarrow 10m$ 10: $\delta \leftarrow 10n-\lfloor 10n\rfloor$fractional part of $10n$ 11: if$\delta =0.5$then 12:    if $\lfloor 10n\rfloor mod2=0$ then 13:      $one\leftarrow \lfloor 10n\rfloor$ round to even 14:    else 15:      $one\leftarrow \lfloor 10n\rfloor +1$ 16:    end if$\delta <0.5$ 17:    $one\leftarrow \lfloor 10n\rfloor$ 18: else 19:    $one\leftarrow \lfloor 10n\rfloor +1$ 20: end if 21: if$v\in \mathrm{irregular}$then 22:    if $\delta >2^{q-2}·{10}^{-k}$ then 23:      $one\leftarrow \lfloor 10n\rfloor +1$ 24:    end if 25:    if $2^{q-2}·{10}^{-k-1}\ge n$ then 26:      $one\leftarrow 0$ 27:    end if 28: else 29:    if $2^{q-1}·{10}^{-k-1}>n$ OR $\left(2^{q-1}·{10}^{-k-1}=n\mathrm{and}cmod2=0\right)$ then 30:      $one\leftarrow 0$ 31:    end if 32:    if $2^{q-1}·{10}^{-k-1}>1-n$ OR $\left(2^{q-1}·{10}^{-k-1}=1-n\mathrm{and}cmod2=0\right)$ then 33:      $one\leftarrow 10$ 34:    end if 35: end if 36: $d\leftarrow ten+one$ 37: return$d,k$

3.4. Lookup Table Precomputation

The algorithm in this paper employs a lookup table to store pre-computed values of ${10}^{-k-1}$ for different ranges of q: $\left[-149,104\right]$ for float and $\left[-1074,971\right]$ for double. These lookup tables use extended precision: 64-bit for float and 128-bit for double. The reference implementation is available in gen.py.

3.4.1. Fundamental Calculation

Let B denote the bit length of each entry in the lookup table, with $B=64$ for float and $B=128$ for double. For any integer $e_{10}$ (representing a power of 10), we aim to represent ${10}^{e_{10}}$ in the form $f·2^{\lfloor e_2\rfloor }$, where $1⩽f<2$ and $e_2$ is a real number. This gives:

$$\begin{array}{c}\hfill f·2^{\lfloor e_2\rfloor }=2^{e_2}={10}^{e_{10}}\end{array}$$

(20)

Taking the logarithm base 2 of both sides, we get:

$$\begin{array}{c}\hfill \lfloor e_2\rfloor =\lfloor e_{10}·{log}_2\left(10\right)\rfloor \end{array}$$

(21)

Solving for f gives:

$$\begin{array}{c}\hfill f={\displaystyle \frac{{10}^{e_{10}}}{2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor }}}\end{array}$$

(22)

The lookup table entries are computed using upward rounding:

$$\begin{array}{cc}\hfill lookup\left[e_{10}\right]& =\lceil f·2^{B-1}\rceil \hfill \\ \hfill & =\lceil {\displaystyle \frac{{10}^{e_{10}}}{2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor }}}·2^{B-1}\rceil \hfill \\ \hfill & =\lceil {10}^{e_{10}}·2^{B-1-\lfloor e_{10}·{log}_2\left(10\right)\rfloor }\rceil \hfill \end{array}$$

(23)

Notably, $f·2^{B-1}$ becomes an integer for certain ranges of $e_{10}$: $0⩽e_{10}⩽27$ for float and $0⩽e_{10}⩽55$ for double.

3.4.2. Detailed Calculation Process

The detailed calculation process is as follows:

• Float
  The range of $-k-1$ is calculated to be [-32, 44] through the q value range in Equation (6), so the lookup table contains representation values from 10 to the power of -32 to 10 to the power of 44. The calculation process is as follows:

  $$\begin{array}{cc}\hfill & -32⩽e_{10}⩽44\hfill \\ \hfill & e_2=\left|\lfloor e_{10}·{log}_2\left(10\right)\rfloor -63\right|\hfill \\ \hfill & pow10t=\left\{\begin{array}{c}{2}^{e_2}//{10}^{\left|e10\right|};\mathrm{if}{e}_{10}<0\\ {10}^{\left|e10\right|}//2^{e_2};\mathrm{if}{e}_{10}⩾20\\ {10}^{\left|e10\right|}·2^{e_2};\mathrm{if}1⩽e_{10}⩽19\end{array}\right.\hfill \\ \hfill & f_{1,e_{10}}=pow10=pow10t+\left(e_{10}⩾0\&\&e_{10}⩽27?0:1\right)\hfill \end{array}$$

  (24)
  When $0⩽e_{10}⩽27$, the lookup table variable indicates that the values $f_{1,e_{10}}·2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor -63}$ and ${10}^{e_{10}}$ are equal. In other cases, the relative error is less than $2^{-63}$. Expressed as:

  $$\begin{array}{cc}\hfill r_{1,e_{10}}& ={\displaystyle \frac{f_{1,e_{10}}·2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor -63}}{{10}^{e_{10}}}}\hfill \\ \hfill & \in \left\{\begin{array}{c}1;\mathrm{if}0⩽e_{10}⩽27\\ \left(1,1+2^{-63}\right);\mathrm{if}{e}_{10}<0\mathrm{or}{e}_{10}>27\end{array}\right.\hfill \end{array}$$

  (25)
• Double
  The range of $-k-1$ is calculated to be [-293, 323] through the q value range in Equation (6), so the lookup table contains representation values from 10 to the power of -293 to 10 to the power of 323. The calculation process is as follows:

  $$\begin{array}{cc}\hfill & -293⩽e_{10}⩽323\hfill \\ \hfill & e_2=\left|\lfloor e_{10}·{log}_2\left(10\right)\rfloor -127\right|\hfill \\ \hfill & pow10t=\left\{\begin{array}{c}{2}^{e_2}//{10}^{\left|e10\right|};\mathrm{if}{e}_{10}<0\\ {10}^{\left|e10\right|}//2^{e_2};\mathrm{if}{e}_{10}⩾39\\ {10}^{\left|e10\right|}·2^{e_2};\mathrm{if}1⩽e_{10}⩽38\end{array}\right.\hfill \\ \hfill & f_{1,e_{10}}=pow10=pow10t+\left(e_{10}⩾0\&\&e_{10}⩽55?0:1\right)\hfill \end{array}$$

  (26)
  When $0⩽e_{10}⩽55$, the lookup table variable indicates that the values $f_{1,e_{10}}·2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor -127}$ and ${10}^{e_{10}}$ are equal. In other cases, the relative error is less than $2^{-127}$. Expressed as:

  $$\begin{array}{cc}\hfill r_{1,e_{10}}& ={\displaystyle \frac{f_{1,e_{10}}·2^{\lfloor e_{10}·{log}_2\left(10\right)\rfloor -127}}{{10}^{e_{10}}}}\hfill \\ \hfill & \in \left\{\begin{array}{c}1;\mathrm{if}0⩽e_{10}⩽55\\ \left(1,1+2^{-127}\right);\mathrm{if}{e}_{10}<0\mathrm{or}{e}_{10}>55\end{array}\right.\hfill \end{array}$$

  (27)

Let $r_1$ denote the error for float lookup table entries, $r_2$ for double entries, and r for both. In Algorithm  (1), we retrieve ${10}^{-k-1}$ from the lookup table. The lookup table provides exact values when q falls within specific ranges:

$$\begin{array}{cc}\hfill \mathrm{float}:& 0⩽-k-1⩽27\Rightarrow -93⩽q⩽-1\hfill \\ \hfill \mathrm{double}:& 0⩽-k-1⩽55\Rightarrow -186⩽q⩽-1\hfill \end{array}$$

(28)

For q outside these ranges, the lookup table entries have bounded relative errors:

$$\begin{array}{cc}\hfill \mathrm{float}:& 0<r_1-1<2^{-63}\hfill \\ \hfill \mathrm{double}:& 0<r_2-1<2^{-127}\hfill \end{array}$$

(29)

3.4.3. Storage Requirements

The float lookup table requires 616 bytes of storage, calculated as $(44-(-32)+1)\times 8$ bytes (77 entries × 8 bytes each). The double lookup table requires 9872 bytes, calculated as $(323-(-293)+1)\times 16$ bytes (617 entries × 16 bytes each).

3.4.4. Implementation Notes

The lookup table pre-computation uses efficient integer arithmetic to avoid precision loss during calculations. The conditional logic in Equations (24) and (26) optimizes the computation based on the sign and magnitude of $e_{10}$, ensuring efficient generation of accurate lookup table entries.

3.5. Efficient Computation of m

This section presents an efficient method for calculating m in Algorithm  (1), which is defined as $m=\lfloor v·{10}^{-k-1}\rfloor$.

3.5.1. Relevant Theorems

We start with some theorems from the Dragonbox algorithm paper:

Let n, P, and Q be positive integers where P and Q are coprime, $P<Q$, $1⩽n⩽n_{max}$, and $Q>n_{max}$. Let $P^{*}/Q^{*}$ be the best rational approximation of $P/Q$ with $Q^{*}⩽n_{max}$ and $P_{*}/Q_{*}$ be the best rational approximation with $Q_{*}⩽n_{max}$.

If $n·P$ does not divide Q evenly:

$$\begin{array}{c}\hfill \lfloor n·{\displaystyle \frac{P}{Q}}\rfloor +1=\lceil n·{\displaystyle \frac{P}{Q}}\rceil \end{array}$$

(30)

Suppose the following holds:

$$\begin{array}{c}\hfill \lfloor n·{\displaystyle \frac{P}{Q}}\rfloor =\lfloor n·\xi \rfloor \end{array}$$

(31)

Then:

$$\begin{array}{c}\hfill {\displaystyle \frac{P_{*}}{Q_{*}}}=\underset{1⩽n⩽n_{max}}{max}{\displaystyle \frac{\lfloor n·\frac{P}{Q}\rfloor }{n}}⩽\xi <\underset{1⩽n⩽n_{max}}{min}{\displaystyle \frac{\lfloor n·\frac{P}{Q}\rfloor +1}{n}}=\underset{1⩽n⩽n_{max}}{min}{\displaystyle \frac{\lceil n·\frac{P}{Q}\rceil }{n}}={\displaystyle \frac{P^{*}}{Q^{*}}}\end{array}$$

(32)

Thus, the range of $\xi$ is:

$$\begin{array}{c}\hfill {\displaystyle \frac{P_{*}}{Q_{*}}}⩽\xi <{\displaystyle \frac{P^{*}}{Q^{*}}}\end{array}$$

(33)

The range of the fractional part of $n·{\displaystyle \frac{P}{Q}}$ is:

$$\begin{array}{c}\hfill \left[{\displaystyle \frac{\left(Q_{*}P\right)\%Q}{Q}},{\displaystyle \frac{\left(Q^{*}P\right)\%Q}{Q}}\right]\end{array}$$

(34)

Here, the fractional part is minimized when $n=Q_{*}$ and maximized when $n=Q^{*}$.

3.5.2. Best Rational Approximation Function

We define the best rational approximation function (implemented in test1.py):

$$\begin{array}{c}\hfill ({\displaystyle \frac{P_{*}}{Q_{*}}},{\displaystyle \frac{P^{*}}{Q^{*}}})=(DN,UP)=f(C,P,Q)\end{array}$$

(35)

This function $f(C,P,Q)$ calculates the best rational approximation with denominator not exceeding C using the Farey sequence median theorem. $DN$ and $UP$ are adjacent terms in the C-th order Farey sequence $F_C$. Therefore, we can calculate Equation (34) very quickly.

3.5.3. Key Proof

In Algorithm  (1), we need to compute $m=\lfloor c·2^q·{10}^{-k-1}\rfloor$. We aim to prove:

$$\begin{array}{c}\hfill m=\lfloor c·2^q·{10}^{-k-1}\rfloor =\lfloor c·2^q·r·{10}^{-k-1}\rfloor \end{array}$$

(36)

Where r is the lookup table error defined in Equations (25) and (27). When condition (28) is met, $r=1$, and the equation holds trivially. For $r\ne 1$:

$$\begin{array}{cc}\hfill \mathrm{float}:& 1<r<1+2^{-63}\hfill \\ \hfill \mathrm{double}:& 1<r<1+2^{-127}\hfill \end{array}$$

(37)

Calculate the range of $2^q·{10}^{-k-1}$ and we get:

$$\begin{array}{c}\hfill 2^q·{10}^{-k-1}={10}^{-1}·\left(2^q·{10}^{-\lfloor q·lg\left(2\right)\rfloor }\right)={10}^{-1}·\left({10}^{q·lg\left(2\right)-\lfloor q·lg\left(2\right)\rfloor }\right)\end{array}$$

(38)

When q is not 0, Equation (38) exists:

$$\begin{array}{cc}\hfill & q·lg\left(2\right)\ne \lfloor q·lg\left(2\right)\rfloor \hfill \\ \hfill & 0<q·lg\left(2\right)-\lfloor q·lg\left(2\right)\rfloor <1\hfill \end{array}$$

(39)

When q is 0, $q·lg\left(2\right)-\lfloor q·lg\left(2\right)\rfloor =0$, so the final conclusion is:

$$\begin{array}{c}\hfill {10}^{-1}⩽2^q·{10}^{-k-1}<1\end{array}$$

(40)

Because there is:

$$\begin{array}{c}\hfill c·2^q·{10}^{-k-1}=c·{\displaystyle \frac{2^{q-k-1}}{5^{k+1}}}\in \left[0.1c\left.,c\right)\right.\end{array}$$

(41)

Therefore:

$$\begin{array}{c}\hfill c·2^q·{10}^{-k-1}=\left\{\begin{array}{c}{\displaystyle \frac{c·2^{q-k-1}}{5^{k+1}}};q⩾1\\ {\displaystyle \frac{c}{2^{1+k-q}·5^{k+1}}}={\displaystyle \frac{c}{10}};q=0\\ {\displaystyle \frac{c·5^{-k-1}}{2^{1+k-q}}};q<0\end{array}\right.\end{array}$$

(42)

Suppose:

$$\begin{array}{c}\hfill c·2^q·{10}^{-k-1}=c·{\displaystyle \frac{x}{y}}<c\end{array}$$

(43)

Then there are:

$$\begin{array}{c}\hfill \left(x,y\right)=\left\{\begin{array}{c}\left(2^{q-k-1},5^{k+1}\right);q⩾1\\ \left(1,10\right);q=0\\ \left(5^{-k-1},2^{1+k-q}\right);q<0\end{array}\right.\end{array}$$

(44)

3.5.4. Bit Width Calculation

Define maximum values for c:

$$\begin{array}{cc}\hfill \mathrm{float}:& c⩽c_{max}=C_1=2^{24}-1\hfill \\ \hfill \mathrm{double}:& c⩽c_{max}=C_2=2^{53}-1\hfill \end{array}$$

(45)

Let C denote either $C_1$ or $C_2$ depending on the precision.

For $y>C$, compute $P^{*}$ and $Q^{*}$ for each q using $f(C,x,y)$ and find the minimum $BIT$ such that:

$$\begin{array}{c}\hfill {\displaystyle \frac{x}{y}}(1+2^{-BIT})<{\displaystyle \frac{P^{*}}{Q^{*}}}\end{array}$$

(46)

For $y⩽C$:

$$\begin{array}{c}\hfill c·{\displaystyle \frac{x}{y}}\left(1+{\displaystyle \frac{1}{Cy}}\right)={\displaystyle \frac{cx+\frac{c}{C}·\frac{x}{y}}{y}}<{\displaystyle \frac{cx+1}{y}}\end{array}$$

(47)

Thus:

$$\begin{array}{c}\hfill \lfloor c·{\displaystyle \frac{x}{y}}\rfloor =\lfloor c·{\displaystyle \frac{x}{y}}\left(1+{\displaystyle \frac{1}{Cy}}\right)\rfloor \end{array}$$

(48)

Similarly, find the minimum $BIT$ such that:

$$\begin{array}{c}\hfill {\displaystyle \frac{x}{y}}(1+2^{-BIT})<{\displaystyle \frac{x}{y}}\left(1+{\displaystyle \frac{1}{Cy}}\right)\end{array}$$

(49)

3.5.5. Results

The maximum of the minimum $BIT$ values for all q (calculated in test1.py in about 1-2 seconds) is:

$$\begin{array}{cc}\hfill \mathrm{float}:& BI{T}_{max}=52\hfill \\ \hfill \mathrm{double}:& BI{T}_{max}=113\hfill \end{array}$$

(50)

Thus:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor c·{\displaystyle \frac{x}{y}}\rfloor =\lfloor c·{\displaystyle \frac{x}{y}}·(1+2^{-52})\rfloor =\lfloor c·{\displaystyle \frac{x}{y}}·r_1\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor c·{\displaystyle \frac{x}{y}}\rfloor =\lfloor c·{\displaystyle \frac{x}{y}}·(1+2^{-113})\rfloor =\lfloor c·{\displaystyle \frac{x}{y}}·r_2\rfloor \hfill \end{array}$$

(51)

This result confirms that m can be calculated efficiently using the lookup table values, even with their inherent errors. Once m is determined, $ten=10m$ can be computed quickly.

3.6. Fast Boundary Condition Testing for $one=0$ and $one=10$

In Algorithm 1, the conditions for determining $one=0$ and $one=10$ appear on lines 31 and 34, respectively. This section introduces an optimized method to quickly test these boundary conditions using equivalent mathematical formulations.

3.6.1. Equivalent Conditions for Boundary Testing

We start by deriving equivalent mathematical conditions for testing $one=0$ and $one=10$.

Case 1: Testing $one=0$

When $2^{-1}·2^q·{10}^{-k-1}=n$, this is equivalent to:

$$\begin{array}{cc}\hfill c·2^q·{10}^{-k-1}-\lfloor c·2^q·{10}^{-k-1}\rfloor & =2^{-1}·2^q·{10}^{-k-1}\hfill \\ \hfill (2c-1)·2^{q-1}·{10}^{-k-1}& =\lfloor c·2^q·{10}^{-k-1}\rfloor \hfill \end{array}$$

(52)

Case 2: Testing $one=10$

When $2^{-1}·2^q·{10}^{-k-1}=1-n$, this is equivalent to:

$$\begin{array}{cc}\hfill \lfloor c·2^q·{10}^{-k-1}\rfloor -c·2^q·{10}^{-k-1}+1& =2^{-1}·2^q·{10}^{-k-1}\hfill \\ \hfill (2c+1)·2^{q-1}·{10}^{-k-1}& =\lfloor c·2^q·{10}^{-k-1}\rfloor +1\hfill \end{array}$$

(53)

3.6.2. Integer Testing Analysis

To further analyze these conditions, we start with the range of $2^{q-1}·{10}^{-k-1}$ from Equation (40):

$$2^{q-1}·{10}^{-k-1}\in [0.05,0.5)$$

(54)

Analysis for $one=0$

For the $one=0$ case, we can derive:

$$\begin{array}{cc}\hfill \lfloor c·2^q·{10}^{-k-1}\rfloor -1& <c·2^q·{10}^{-k-1}-0.5\hfill \\ \hfill & <(2c-1)·2^{q-1}·{10}^{-k-1}\hfill \\ \hfill & ⩽c·2^q·{10}^{-k-1}-0.05<\lfloor c·2^q·{10}^{-k-1}\rfloor +1\hfill \end{array}$$

(55)

This implies that when $(2c-1)·2^{q-1}·{10}^{-k-1}$ is an integer, it must equal $\lfloor c·2^q·{10}^{-k-1}\rfloor$.

Analysis for $one=10$

Similarly, for the $one=10$ case:

$$\begin{array}{cc}\hfill \lfloor c·2^q·{10}^{-k-1}\rfloor & <c·2^q·{10}^{-k-1}+0.05\hfill \\ \hfill & ⩽(2c+1)·2^{q-1}·{10}^{-k-1}\hfill \\ \hfill & <c·2^q·{10}^{-k-1}+0.5<\lfloor c·2^q·{10}^{-k-1}\rfloor +2\hfill \end{array}$$

(56)

This implies that when $(2c+1)·2^{q-1}·{10}^{-k-1}$ is an integer, it must equal $\lfloor c·2^q·{10}^{-k-1}\rfloor +1$.

3.6.3. Key Insight: Integer Divisibility Test

The key insight is that testing for $one=0$ or $one=10$ is equivalent to checking whether $(2c\pm 1)·2^{q-1}·{10}^{-k-1}$ is an integer. This can be rewritten as:

$$(2c\pm 1)·2^{q-1}·{10}^{-k-1}=(2c\pm 1)·2^{q-k-2}·5^{-k-1}$$

(57)

We analyze different ranges of q to simplify this condition:

• Case $q⩾2$: From $q⩾2$, we get $k⩾0$. The expression simplifies to checking if $(2c\pm 1)·2^{q-k-2}$ is divisible by $5^{k+1}$. Since 2 and 5 are coprime, this reduces to checking if $(2c\pm 1)$ is divisible by $5^{k+1}$:

  $$(2c\pm 1)mod{5}^{k+1}=0$$

  (58)
  Let t be a positive integer such that $2c\pm 1=t·5^{k+1}$. Since $2c\pm 1$ is odd, t must also be odd. Considering the ranges of c for float and double:

  $$\begin{array}{cc}\hfill \mathrm{float}:& 2c-1\in [2^{24}+1,2^{25}-3];2c+1\in [2^{24}+3,2^{25}-1];\hfill \\ \hfill \mathrm{double}:& 2c-1\in [2^{53}+1,2^{54}-3];2c+1\in [2^{53}+3,2^{54}-1];\hfill \end{array}$$

  (59)
  This gives us the range for t:

  $$\begin{array}{cc}\hfill \mathrm{float}:& {\displaystyle \frac{2^{24}+1}{5^{k+1}}}⩽t⩽{\displaystyle \frac{2^{25}-1}{5^{k+1}}};\hfill \\ \hfill \mathrm{double}:& {\displaystyle \frac{2^{53}+1}{5^{k+1}}}⩽t⩽{\displaystyle \frac{2^{54}-1}{5^{k+1}}};\hfill \end{array}$$

  (60)
  The maximum values of k where t can be at least one odd integer are:

  $$\begin{array}{cc}\hfill \mathrm{float}:& k_{max}=9\Rightarrow q_{max}=33,t=3\hfill \\ \hfill \mathrm{double}:& k_{max}=22\Rightarrow q_{max}=76,t=1\hfill \end{array}$$

  (61)
• Case $1⩾q⩾0$: The denominator $2^{2+k-q}·5^{k+1}$ is even, while the numerator $(2c\pm 1)$ is odd, so no solution exists.
• Case $q<0$: The denominator $2^{2+k-q}$ is even, while the numerator $(2c\pm 1)·5^{-k-1}$ is odd, so no solution exists.

3.6.4. Summary of Boundary Conditions

In summary, the situations when $(2c\pm 1)·2^{q-1}·{10}^{-k-1}$ is an integer are as follows:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2⩽q⩽33\&\&(2c\pm 1)mod{5}^{k+1}=0;\hfill \\ \hfill \mathrm{double}:& 2⩽q⩽76\&\&(2c\pm 1)mod{5}^{k+1}=0;\hfill \end{array}$$

(62)

The range of $-k-1$ is:

$$\begin{array}{cc}\hfill \mathrm{float}:& -10⩽-k-1⩽-1\hfill \\ \hfill \mathrm{double}:& -23⩽-k-1⩽-1\hfill \end{array}$$

(63)

3.6.5. Efficient Implementation

We can further simplify the testing conditions using bitwise operations. For $one=0$:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{64}·n\rfloor \hfill \end{array}$$

(64)

When $2^{-1}·2^q·{10}^{-k-1}=1-n$, the following conclusions can be drawn:

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{c}{2}^{35}·2^q·{10}^{-k-1}=2^{36}-2^{36}·n\Rightarrow \\ \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor =2^{36}-1-\lfloor 2^{36}·n\rfloor \end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{c}{2}^{63}·2^q·{10}^{-k-1}=2^{64}-2^{64}·n\Rightarrow \\ \lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{64}-2^{64}·n\rfloor =2^{64}-1-\lfloor 2^{64}·n\rfloor \end{array}\right.\hfill \end{array}$$

(65)

The discussion on whether $\lfloor 2^{36}-2^{36}·n\rfloor =2^{36}-1-\lfloor 2^{36}·n\rfloor$ in Equation (65) holds true, that is, whether $2^{36}·n$ in Equation (65) is an integer, or equivalent to discussing whether the following values are integers when Equation (62) holds true (the same applies to double) :

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{36}·(m+n)=c·2^{q+36}·{10}^{-k-1}=c·2^{q-k+35}·5^{-k-1}=c·{\displaystyle \frac{2^{q-k+35}}{5^{k+1}}}\hfill \\ \hfill \mathrm{double}:& 2^{64}·(m+n)=c·2^{q+64}·{10}^{-k-1}=c·2^{q-k+63}·5^{-k-1}=c·{\displaystyle \frac{2^{q-k+63}}{5^{k+1}}}\hfill \end{array}$$

(66)

Suppose c can divide $5^{k+1}$ evenly (where t is a temporary integer variable):

$$\begin{array}{c}\hfill c=t·5^{k+1};t⩾1\end{array}$$

(67)

Therefore, when Equation (67) was established, there were:

$$\begin{array}{c}\hfill 2c\pm 1=2·t·5^{k+1}\pm 1\end{array}$$

(68)

Expression (68) cannot divide $5^{k+1}$ evenly, which contradicts Equation (62), so c cannot divide $5^{k+1}$ evenly. Therefore, for float, $c·2^{q+36}·{10}^{-k-1}$ and $2^{36}·n$ are not integers; For double, $c·2^{64+q}·{10}^{-k-1}$ and $2^{64}·n$ are not integers, that is:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{36}-2^{36}·n\rfloor =2^{36}+\lfloor -2^{36}·n\rfloor =2^{36}-1-\lfloor 2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor 2^{64}-2^{64}·n\rfloor =2^{64}+\lfloor -2^{64}·n\rfloor =2^{64}-1-\lfloor 2^{64}·n\rfloor \hfill \end{array}$$

(69)

Therefore, the conclusion (65) is correct. Discuss the necessary and sufficient conditions for whether $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor$ is $2^{-1}·2^q·{10}^{-k-1}=n$. The same applies to double, expressed as:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}=n\iff \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}=n\iff \lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{64}·n\rfloor \hfill \end{array}$$

(70)

Similarly, the necessary and sufficient conditions for whether $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor$ is $2^{-1}·2^q·{10}^{-k-1}=1-n$. The same applies to double, expressed as:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}=1-n\iff \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}=1-n\iff \lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{64}-2^{64}·n\rfloor \hfill \end{array}$$

(71)

The sufficient conditions of Equations (70) and (71) are obviously established. Introduce the proof that Equation (70) holds. For float, only the necessary conditions need to be discussed, that is, whether $2^{-1}·2^q·{10}^{-k-1}=n$ must hold true when $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor$ holds, or equivalent to $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor \ne \lfloor 2^{36}·n\rfloor$ must hold true when $2^{-1}·2^q·{10}^{-k-1}\ne n$. The following is proved by proof by contradiction.

Assume that $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor$ holds when $2^{-1}·2^q·{10}^{-k-1}\ne n$. Then there is:

$$\begin{array}{cc}\hfill & \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor \hfill \\ \hfill & \Rightarrow 0<\left|2^{35}·2^q·{10}^{-k-1}-2^{36}·n\right|<1\hfill \\ \hfill & \Rightarrow 0<\left|\left(2c-1\right)·2^{q-1}·{10}^{-k-1}-m\right|<2^{-36}\hfill \end{array}$$

(72)

As is known from Equation (55), there is:

$$\begin{array}{c}\hfill m-1<\left(2c-1\right)·2^{q-1}·{10}^{-k-1}<m+1\end{array}$$

(73)

Suppose the decimal part of $\left(2c-1\right)·2^{q-1}·{10}^{-k-1}$ is represented as $n^{-}$, thus we have:

$$\begin{array}{c}\hfill \left|\left(2c-1\right)·2^{q-1}·{10}^{-k-1}-m\right|=\left\{\begin{array}{c}{n}^{-};\mathrm{if}\left(2c-1\right)·2^{q-1}·{10}^{-k-1}>m\\ 1-n^{-};\mathrm{if}\left(2c-1\right)·2^{q-1}·{10}^{-k-1}<m\end{array}\right.\end{array}$$

(74)

Substitute expression (74) into expression (72), and we get:

$$\begin{array}{cc}\hfill & 0<\left|\left(2c-1\right)·2^{q-1}·{10}^{-k-1}-m\right|<2^{-36}\hfill \\ \hfill & \Rightarrow 0<n^{-}<2^{-36}\mathrm{or}0<1-n^{-}<2^{-36}\hfill \end{array}$$

(75)

Similarly, it can be known that the double range is the range of $n^{-}$. Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& n^{-}\in \left(0,2^{-36}\right)\cup \left(1-2^{-36},1\right)\hfill \\ \hfill \mathrm{double}:& n^{-}\in \left(0,2^{-64}\right)\cup \left(1-2^{-64},1\right)\hfill \end{array}$$

(76)

When $2^{-1}·2^q·{10}^{-k-1}\ne n$, it is known from Equation (52) that $\left(2c-1\right)·2^{q-1}·{10}^{-k-1}$ is not an integer. Therefore, there is:

$$\begin{array}{c}\hfill 0<n^{-}<1\end{array}$$

(77)

It is only necessary to prove that Equation (76) does not hold. Discuss the range of the decimal part $n^{-}$ when $\left(2c-1\right)·2^{q-1}·{10}^{-k-1}$ is not an integer. According to Equation (57), there are:

$$\begin{array}{c}\hfill \left(2c-1\right)·2^{q-1}·{10}^{-k-1}=\left(2c-1\right)·{\displaystyle \frac{x}{y}}=\left\{\begin{array}{c}{\displaystyle \frac{\left(2c-1\right)·2^{q-k-2}}{5^{k+1}}};q⩾2\\ {\displaystyle \frac{\left(2c-1\right)}{2^{2+k-q}·5^{k+1}}};1⩾q⩾0\\ {\displaystyle \frac{\left(2c-1\right)·5^{-k-1}}{2^{2+k-q}}};q<0\end{array}\right.\end{array}$$

(78)

The maximum value of $2c-1$ is:

$$\begin{array}{cc}\hfill \mathrm{float}:& {\left(2c-1\right)}_{max}=2^{25}-3\hfill \\ \hfill \mathrm{double}:& {\left(2c-1\right)}_{max}=2^{54}-3\hfill \end{array}$$

(79)

Discuss based on the denominator range in Equation (78).

• $y⩽{\left(2c-1\right)}_{max}$
  When $y⩽{\left(2c-1\right)}_{max}$, $y_{max}$ is the expression (79), the following holds true:

  $$\begin{array}{c}\hfill {\displaystyle \frac{1}{y_{max}}}⩽n^{-}⩽1-{\displaystyle \frac{1}{y_{max}}}\\ \hfill {\displaystyle \frac{1}{y_{max}}}⩽1-n^{-}⩽1-{\displaystyle \frac{1}{y_{max}}}\end{array}$$

  (80)
  Therefore, when $y⩽{\left(2c-1\right)}_{max}$, Equation (76) does not hold true.
• $y>{\left(2c-1\right)}_{max}$
  Call function (35) to calculate the approximation results $P_{*}/Q_{*}$ and $P^{*}/Q^{*}$ of all possible upper and lower limit rational numbers:

  $$\begin{array}{c}\hfill \left({\displaystyle \frac{P_{*}}{Q_{*}}},{\displaystyle \frac{P^{*}}{Q^{*}}}\right)=f\left({\left(2c-1\right)}_{max},x,y\right)\end{array}$$

  (81)
  Therefore, for $n^{-}$, the following conclusion can be drawn from formula (34).

  $$\begin{array}{c}\hfill n^{-}\in \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\end{array}$$

  (82)
  By exhausting all possibilities, we thus have (the test code file is test3.py) :

  $$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-33}<n^{-}<1-2^{-29}\hfill \\ \hfill \mathrm{double}:& 2^{-62}<n^{-}<1-2^{-63}\hfill \end{array}$$

  (83)

  $$\begin{array}{cc}\hfill \mathrm{float}:& \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(0,2^{-36}\right)=⌀\hfill \\ \hfill & \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(1-2^{-36},1\right)=⌀\hfill \\ \hfill \mathrm{double}:& \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(0,2^{-64}\right)=⌀\hfill \\ \hfill & \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(1-2^{-64},1\right)=⌀\hfill \end{array}$$

  (84)
  Therefore, when $y>{\left(2c-1\right)}_{max}$, Equation (76) does not hold true.

In summary, when $2^{-1}·2^q·{10}^{-k-1}\ne n$, Equation (76) does not hold true, that is, $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor \ne \lfloor 2^{36}·n\rfloor$ must hold true. Therefore, when $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}·n\rfloor$ holds, $2^{-1}·2^q·{10}^{-k-1}=n$ must hold true. Therefore, Equation (70) holds.

Similarly, it can be proved that when $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor$ holds, $2^{-1}·2^q·{10}^{-k-1}=1-n$ must hold true. The same applies to double. Similarly, by proof of contradiction, for float, it is assumed that when $2^{-1}·2^q·{10}^{-k-1}\ne 1-n$ holds, $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor$ holds. That is:

$$\begin{array}{cc}\hfill & \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor \hfill \\ \hfill & \Rightarrow 0<\left|2^{35}·2^q·{10}^{-k-1}-2^{36}+2^{36}·n\right|<1\hfill \\ \hfill & \Rightarrow 0<\left|2^{q-1}·{10}^{-k-1}-1+n\right|<2^{-36}\hfill \\ \hfill & \Rightarrow -2^{-36}<\left(2c+1\right)·2^{q-1}·{10}^{-k-1}-m-1<2^{-36}\hfill \end{array}$$

(85)

As is known from Equation (56), there is:

$$\begin{array}{c}\hfill m<\left(2c+1\right)·2^{q-1}·{10}^{-k-1}<m+2\end{array}$$

(86)

Suppose the decimal part of $\left(2c+1\right)·2^{q-1}·{10}^{-k-1}$ is represented as $n^{+}$, thus we have:

$$\begin{array}{c}\hfill \left(2c+1\right)·2^{q-1}·{10}^{-k-1}-m-1=\left\{\begin{array}{c}{n}^{+};\mathrm{if}\left(2c+1\right)·2^{q-1}·{10}^{-k-1}>m+1\\ 1-n^{+};\mathrm{if}\left(2c+1\right)·2^{q-1}·{10}^{-k-1}<m+1\end{array}\right.\end{array}$$

(87)

Substitute expression (87) into expression (85), and we get:

$$\begin{array}{cc}\hfill & 0<\left|\left(2c+1\right)·2^{q-1}·{10}^{-k-1}-m-1\right|<2^{-36}\hfill \\ \hfill & \Rightarrow 0<1-n^{+}<2^{-36}\mathrm{or}0<n^{+}<2^{-36}\hfill \end{array}$$

(88)

Similarly, it can be known that the double range is the range of $n^{+}$. Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& n^{+}\in \left(0,2^{-36}\right)\cup \left(1-2^{-36},1\right)\hfill \\ \hfill \mathrm{double}:& n^{+}\in \left(0,2^{-64}\right)\cup \left(1-2^{-64},1\right)\hfill \end{array}$$

(89)

When $2^{-1}·2^q·{10}^{-k-1}\ne 1-n$, it is known from Equation (53) that $\left(2c+1\right)·2^{q-1}·{10}^{-k-1}$ is not an integer. Therefore, there is:

$$\begin{array}{c}\hfill 0<n^{+}<1\end{array}$$

(90)

It is only necessary to prove that Equation (89) does not hold. Discuss the range of the decimal part $n^{+}$ when $\left(2c+1\right)·2^{q-1}·{10}^{-k-1}$ is not an integer. According to Equation (57), there are:

$$\begin{array}{c}\hfill \left(2c+1\right)·2^{q-1}·{10}^{-k-1}=\left(2c+1\right)·{\displaystyle \frac{x}{y}}=\left\{\begin{array}{c}{\displaystyle \frac{\left(2c+1\right)·2^{q-k-2}}{5^{k+1}}};q⩾2\\ {\displaystyle \frac{\left(2c+1\right)}{2^{2+k-q}·5^{k+1}}};1⩾q⩾0\\ {\displaystyle \frac{\left(2c+1\right)·5^{-k-1}}{2^{2+k-q}}};q<0\end{array}\right.\end{array}$$

(91)

The maximum value of $2c+1$ is:

$$\begin{array}{cc}\hfill \mathrm{float}:& {\left(2c+1\right)}_{max}=2^{25}-1\hfill \\ \hfill \mathrm{double}:& {\left(2c+1\right)}_{max}=2^{54}-1\hfill \end{array}$$

(92)

Discuss based on the denominator range in Equation (91).

• $y⩽{\left(2c+1\right)}_{max}$
  When $y⩽{\left(2c+1\right)}_{max}$, $y_{max}$ is the expression (92), the following holds true:

  $$\begin{array}{c}\hfill {\displaystyle \frac{1}{y_{max}}}⩽n^{+}⩽1-{\displaystyle \frac{1}{y_{max}}}\\ \hfill {\displaystyle \frac{1}{y_{max}}}⩽1-n^{+}⩽1-{\displaystyle \frac{1}{y_{max}}}\end{array}$$

  (93)
  Therefore, when $y⩽{\left(2c+1\right)}_{max}$, Equation (89) does not hold true.
• $y>{\left(2c+1\right)}_{max}$
  Call function (35) to calculate the approximation results ${\displaystyle \frac{P_{*}}{Q_{*}}}$ and ${\displaystyle \frac{P^{*}}{Q^{*}}}$ of all possible upper and lower limit rational numbers:

  $$\begin{array}{c}\hfill \left({\displaystyle \frac{P_{*}}{Q_{*}}},{\displaystyle \frac{P^{*}}{Q^{*}}}\right)=f\left({\left(2c+1\right)}_{max},x,y\right)\end{array}$$

  (94)
  Therefore, for $n^{+}$, the following conclusion can be drawn from formula (34).

  $$\begin{array}{c}\hfill n^{+}\in \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\end{array}$$

  (95)
  By exhausting all possibilities, we thus have (the test code file is test7.py) :

  $$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-33}<n^{+}<1-2^{-29}\hfill \\ \hfill \mathrm{double}:& 2^{-62}<n^{+}<1-2^{-63}\hfill \end{array}$$

  (96)

  $$\begin{array}{cc}\hfill \mathrm{float}:& \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(0,2^{-36}\right)=⌀\hfill \\ \hfill & \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(1-2^{-36},1\right)=⌀\hfill \\ \hfill \mathrm{double}:& \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(0,2^{-64}\right)=⌀\hfill \\ \hfill & \left[{\displaystyle \frac{\left(Q_{*}x\right)\%y}{y}},{\displaystyle \frac{\left(Q^{*}x\right)\%y}{y}}\right]\cap \left(1-2^{-64},1\right)=⌀\hfill \end{array}$$

  (97)
  Therefore, when $y>{\left(2c+1\right)}_{max}$, Equation (89) does not hold true.

In summary, when $2^{-1}·2^q·{10}^{-k-1}\ne 1-n$, Equation (89) does not hold true, that is, $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor \ne \lfloor 2^{36}-2^{36}·n\rfloor$ must hold true. Therefore, when $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =\lfloor 2^{36}-2^{36}·n\rfloor$ holds, $2^{-1}·2^q·{10}^{-k-1}=1-n$ must hold true. The same is true for double.Therefore, Equation (71) holds.

The following conclusions hold:

$$\begin{array}{ccc}\hfill \mathrm{float}:& \lfloor 2^{36}-2^{36}·n\rfloor \hfill & \hfill =\left\{\begin{array}{c}{2}^{36}-1-\lfloor 2^{36}·n\rfloor ;\mathrm{if}c·2^{36+q}·{10}^{-k-1}\notin Z\\ 2^{36}-\lfloor 2^{36}·n\rfloor ;\mathrm{if}c·2^{36+q}·{10}^{-k-1}\in Z\end{array}\right.\\ \hfill \mathrm{double}:& \lfloor 2^{64}-2^{64}·n\rfloor \hfill & \hfill =\left\{\begin{array}{c}{2}^{64}-1-\lfloor 2^{64}·n\rfloor ;\mathrm{if}c·2^{64+q}·{10}^{-k-1}\notin Z\\ 2^{64}-\lfloor 2^{64}·n\rfloor ;\mathrm{if}c·2^{64+q}·{10}^{-k-1}\in Z\end{array}\right.\end{array}$$

(98)

Discuss whether the following Equation (99) holds when conditions (62) and (63) are met:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}\rfloor =\lfloor c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}·r\rfloor \hfill \\ \hfill & =\lfloor c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}·{\displaystyle \frac{\left(2^{63-\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor }//{10}^{k+1}\right)+1}{{10}^{-k-1}}}·2^{\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor -63}\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}\rfloor =\lfloor c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}·r\rfloor \hfill \\ \hfill & =\lfloor c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}·{\displaystyle \frac{\left(2^{127-\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor }//{10}^{k+1}\right)+1}{{10}^{-k-1}}}·2^{\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor -127}\rfloor \hfill \end{array}$$

(99)

There are:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}\rfloor =\lfloor 2^{36}·\left(m+n\right)\rfloor =2^{36}·m+\lfloor 2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}\rfloor =\lfloor 2^{64}·\left(m+n\right)\rfloor =2^{64}·m+\lfloor 2^{64}·n\rfloor \hfill \end{array}$$

(100)

It has been proven earlier that m can be accurately calculated. Then, when (99) holds true, the values $\lfloor 2^{36}·n\rfloor$ and $\lfloor 2^{64}·n\rfloor$ on the right side of Equations (64) and (65) can be accurately calculated.

From Equation (57), we have:

$$\begin{array}{c}\hfill c={\displaystyle \frac{t·5^{k+1}-1}{2}}\end{array}$$

(101)

Substituting Equation (101) into Equation (99), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}=t·2^{q+34-k}-{\displaystyle \frac{2^{q+34-k}}{5^{k+1}}}\hfill \\ \hfill \mathrm{double}:& c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}=t·2^{q+62-k}-{\displaystyle \frac{2^{q+62-k}}{5^{k+1}}}\hfill \end{array}$$

(102)

When conditions (62) and (63) are met, $t·2^{q+34-k}$ and $t·2^{q+62-k}$ are integers. Under the condition of meeting condition (62), the decimal part of expression (102) is represented as:

$$\begin{array}{cc}\hfill \mathrm{float}:& {\displaystyle \frac{2^{q+34-k}\%5^{k+1}}{5^{k+1}}};2⩽q⩽33\hfill \\ \hfill \mathrm{double}:& {\displaystyle \frac{2^{q+62-k}\%5^{k+1}}{5^{k+1}}};2⩽q⩽76\hfill \end{array}$$

(103)

It is only necessary to prove that the increase in the value $c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}·r$ on the right side of the expression compared to the value $c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}$ on the left side plus the decimal part of the value on the left side is less than 1 for Equation (99) to hold true. That is:

$$\begin{array}{cc}\hfill \mathrm{float}:& {\displaystyle \frac{2^{q+34-k}\%5^{k+1}}{5^{k+1}}}+\left(c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}·r-c·{\displaystyle \frac{2^{q+35-k}}{5^{k+1}}}\right)<1\hfill \\ \hfill \mathrm{double}:& {\displaystyle \frac{2^{q+62-k}\%5^{k+1}}{5^{k+1}}}+\left(c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}·r-c·{\displaystyle \frac{2^{q+63-k}}{5^{k+1}}}\right)<1\hfill \end{array}$$

(104)

By exhaustionally calculating the maximum possible c value under each q and substituting it into Equation (104), it holds. The calculation result is in test2.py. The calculation results show that for the float range and the double range, Equation (104) always holds true. Therefore, Equation (99) holds true, and thus the values of $\lfloor 2^{36}·n\rfloor$ and $\lfloor 2^{64}·n\rfloor$ on the right side of Equations (64) and (65) can be accurately calculated. The values of $\lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor$ and $\lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor$ on the left side of Equations (64) and (65) can be calculated through lookup tables.

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{35}·2^q·{10}^{-k-1}\rfloor =pow10\gg \left(28-q-\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor \right)\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor =pow10\gg \left(64-q-\lfloor \left(-k-1\right)·{log}_2\left(10\right)\rfloor \right)\hfill \end{array}$$

(105)

The code file for verifying the validity of Equation (105) is test4.py. Therefore, when conditions (62) and (63) are met, the values of both sides of Equations (64) and (65) can be accurately calculated.

Discuss the relationship between the following two values within all ranges of floating-point numbers:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor c·2^{q+36}·{10}^{-k-1}\rfloor ;\lfloor c·2^{q+36}·r·{10}^{-k-1}\rfloor ;\hfill \\ \hfill \mathrm{double}:& \lfloor c·2^{q+64}·{10}^{-k-1}\rfloor ;\lfloor c·2^{q+64}·r·{10}^{-k-1}\rfloor ;\hfill \end{array}$$

(106)

When $r=1$, it is obvious that the two values in expression (106) are equal. When $r\ne 1$, or equivalent to $r>1$, has:

$$\begin{array}{cc}\hfill \mathrm{float}:c·2^{q+36}·r·{10}^{-k-1}& =c·2^{q+36}·{10}^{-k-1}+c·2^{q+36}·\left(r-1\right)·{10}^{-k-1}\hfill \\ \hfill & <c·2^{q+36}·{10}^{-k-1}+2^{24}·2^{36}·2^q·{10}^{-k-1}·\left(r-1\right)\hfill \\ \hfill & <c·2^{q+36}·{10}^{-k-1}+2^{-3}\hfill \\ \hfill \lfloor c·2^{q+36}·r·{10}^{-k-1}\rfloor & ⩽\lfloor c·2^{q+36}·{10}^{-k-1}\rfloor +1\hfill \\ \hfill \mathrm{double}:c·2^{q+64}·r·{10}^{-k-1}& =c·2^{q+64}·{10}^{-k-1}+c·2^{q+64}·\left(r-1\right)·{10}^{-k-1}\hfill \\ \hfill & <c·2^{q+64}·{10}^{-k-1}+2^{53}·2^{64}·2^q·{10}^{-k-1}·\left(r-1\right)\hfill \\ \hfill & <c·2^{q+64}·{10}^{-k-1}+2^{-10}\hfill \\ \hfill \lfloor c·2^{q+64}·r·{10}^{-k-1}\rfloor & ⩽\lfloor c·2^{q+64}·{10}^{-k-1}\rfloor +1\hfill \end{array}$$

(107)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& 0⩽\lfloor c·2^{q+36}·r·{10}^{-k-1}\rfloor -\lfloor c·2^{q+36}·{10}^{-k-1}\rfloor ⩽1\hfill \\ \hfill \mathrm{double}:& 0⩽\lfloor c·2^{q+64}·r·{10}^{-k-1}\rfloor -\lfloor c·2^{q+64}·{10}^{-k-1}\rfloor ⩽1\hfill \end{array}$$

(108)

Because there is:

$$\begin{array}{c}\hfill \lfloor c·2^q·{10}^{-k-1}\rfloor =\lfloor c·2^q·r·{10}^{-k-1}\rfloor =m\end{array}$$

(109)

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor c·2^{q+36}·{10}^{-k-1}\rfloor =2^{36}·m+\lfloor 2^{36}·n\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor c·2^{q+64}·{10}^{-k-1}\rfloor =2^{64}·m+\lfloor 2^{64}·n\rfloor \hfill \end{array}$$

(110)

Suppose:

$$\begin{array}{c}\hfill n_r=c·2^q·r·{10}^{-k-1}-m\end{array}$$

(111)

Therefore, the following conclusion can be drawn: when condition (62) is met, from Equation (99), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2⩽q⩽33\&\&\left(2c\pm 1\right)\%5^{k+1}=0\Rightarrow \lfloor 2^{36}·n\rfloor =\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \mathrm{double}:& 2⩽q⩽76\&\&\left(2c\pm 1\right)\%5^{k+1}=0\Rightarrow \lfloor 2^{64}·n\rfloor =\lfloor 2^{64}·n_r\rfloor \hfill \end{array}$$

(112)

Within the range of floating-point numbers, there exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{36}·n\rfloor ⩽\lfloor 2^{36}·n_r\rfloor ⩽\lfloor 2^{36}·n\rfloor +1\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{64}·n\rfloor ⩽\lfloor 2^{64}·n_r\rfloor ⩽\lfloor 2^{64}·n\rfloor +1\hfill \end{array}$$

(113)

To simplify the expression, $even$ is used to indicate whether c is an even number:

$$\begin{array}{c}\hfill even=(c+1)\%2\in \left\{0,1\right\}\end{array}$$

(114)

When $2^{-1}·2^q·{10}^{-k-1}=n$ or $2^{-1}·2^q·{10}^{-k-1}=1-n$, $2^{-1}·2^q·{10}^{-k-1}=n$ is the boundary condition for $one=0$, and $2^{-1}·2^q·{10}^{-k-1}=1-n$ is the boundary condition for $one=10$. Whether $one$ is 0 or 10 is determined based on whether c is an even number.Therefore, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{c}one=0:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even>\lfloor 2^{36}·n_r\rfloor \\ one=10:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even>2^{36}-1-\lfloor 2^{36}·n_r\rfloor \end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{c}one=0:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even>\lfloor 2^{64}·n_r\rfloor \\ one=10:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even>2^{64}-1-\lfloor 2^{64}·n_r\rfloor \end{array}\right.\hfill \end{array}$$

(115)

Therefore, when $2^{-1}·2^q·{10}^{-k-1}=n$ or $2^{-1}·2^q·{10}^{-k-1}=1-n$, we can use the condition (116) to determine whether $one=0$ or $one=10$.

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{c}\mathrm{if}\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even>\lfloor 2^{36}·n_r\rfloor :one=0\\ \mathrm{if}\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even>2^{36}-1-\lfloor 2^{36}·n_r\rfloor :one=10\end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{c}\mathrm{if}\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even>\lfloor 2^{64}·n_r\rfloor :one=0\\ \mathrm{if}\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even>2^{64}-1-\lfloor 2^{64}·n_r\rfloor :one=10\end{array}\right.\hfill \end{array}$$

(116)

When $2^{-1}·2^q·{10}^{-k-1}>n$ or $2^{-1}·2^q·{10}^{-k-1}>1-n$, We can also use the above condition (116) to determine whether $one=0$ or $one=10$. When $2^{-1}·2^q·{10}^{-k-1}<n$ or $2^{-1}·2^q·{10}^{-k-1}<1-n$, we can also use the above condition (116) to determine whether $one\ne 0$ or $one\ne 10$. There are a total of four situations.The proof is as follows:

(1)When $2^{-1}·2^q·{10}^{-k-1}<n$ , there must exist $one\ne 0$, and there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}-n=n^{-}-1\in \left(2^{-33}-1,-2^{-29}\right)\hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}-n=n^{-}-1\in \left(2^{-62}-1,-2^{-63}\right)\hfill \end{array}$$

(117)

Therefore, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{q+35}·{10}^{-k-1}-2^{36}·n\in \left(2^3-2^{36},-2^7\right)\hfill \\ \hfill \mathrm{double}:& 2^{q+63}·{10}^{-k-1}-2^{64}·n\in \left(4-2^{64},-2\right)\hfill \end{array}$$

(118)

Suppose there are two real numbers a and b, and the following relationship must exist:

$$\begin{array}{cc}\hfill 0⩽& b-\lfloor b\rfloor <1\hfill \\ \hfill a-\lfloor a\rfloor -1<& b-\lfloor b\rfloor <1+a-\lfloor a\rfloor \hfill \\ \hfill a-b-1<& \lfloor a\rfloor -\lfloor b\rfloor <a-b+1\hfill \end{array}$$

(119)

When $a=2^{q+35}·{10}^{-k-1}$ and $b=2^{36}·n$ or $a=2^{q+63}·{10}^{-k-1}$ and $b=2^{64}·n$, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor -\lfloor 2^{36}·n\rfloor <2^{q+35}·{10}^{-k-1}-2^{36}·n+1\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor -\lfloor 2^{64}·n\rfloor <2^{q+63}·{10}^{-k-1}-2^{64}·n+1\hfill \end{array}$$

(120)

From Equation (118), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor -\lfloor 2^{36}·n\rfloor <1-2^7<0\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor -\lfloor 2^{64}·n\rfloor <1-2<0\hfill \end{array}$$

(121)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& ⩽\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +1\hfill \\ \hfill & <\lfloor 2^{36}·n\rfloor ⩽\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& <\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \mathrm{double}:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& ⩽\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +1\hfill \\ \hfill & <\lfloor 2^{64}·n\rfloor ⩽\lfloor 2^{64}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& <\lfloor 2^{64}·n_r\rfloor \hfill \end{array}$$

(122)

Therefore, when $2^{-1}·2^q·{10}^{-k-1}<n$, the condition (116) can be used to determine that $one\ne 0$.

(2)When $2^{-1}·2^q·{10}^{-k-1}>n$, there must exist $one=0$, and there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}-n=n^{-}\in \left(2^{-33},1-2^{-29}\right)\hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}-n=n^{-}\in \left(2^{-62},1-2^{-63}\right)\hfill \end{array}$$

(123)

Therefore, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{q+35}·{10}^{-k-1}-2^{36}·n\in \left(2^3,2^{36}-2^7\right)\hfill \\ \hfill \mathrm{double}:& 2^{q+63}·{10}^{-k-1}-2^{64}·n\in \left(4,2^{64}-2\right)\hfill \end{array}$$

(124)

When $a=2^{q+35}·{10}^{-k-1}$ and $b=2^{36}·n$ or $a=2^{q+63}·{10}^{-k-1}$ and $b=2^{64}·n$, from Equation (119), the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor -\lfloor 2^{36}·n\rfloor >2^{q+35}·{10}^{-k-1}-2^{36}·n-1\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor -\lfloor 2^{64}·n\rfloor >2^{q+63}·{10}^{-k-1}-2^{64}·n-1\hfill \end{array}$$

(125)

From Equation (124), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor -\lfloor 2^{36}·n\rfloor >2^3-1⩾0\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor -\lfloor 2^{64}·n\rfloor >4-1⩾0\hfill \end{array}$$

(126)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& ⩾\lfloor 2^{q+35}·{10}^{-k-1}\rfloor \hfill \\ \hfill & >\lfloor 2^{36}·n\rfloor +1⩾\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& >\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \mathrm{double}:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& ⩾\lfloor 2^{q+63}·{10}^{-k-1}\rfloor \hfill \\ \hfill & >\lfloor 2^{64}·n\rfloor +1⩾\lfloor 2^{64}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& >\lfloor 2^{64}·n_r\rfloor \hfill \end{array}$$

(127)

Therefore, when $2^{-1}·2^q·{10}^{-k-1}>n$, the condition (116) can be used to determine that $one=0$.

(3)When $2^{-1}·2^q·{10}^{-k-1}<1-n$ , there must exist $one\ne 10$, and there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}+n=n^{+}\in \left(2^{-33},1-2^{-29}\right)\hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}+n=n^{+}\in \left(2^{-62},1-2^{-63}\right)\hfill \end{array}$$

(128)

Therefore, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{q+35}·{10}^{-k-1}+2^{36}·n\in \left(2^3,2^{36}-2^7\right)\hfill \\ \hfill \mathrm{double}:& 2^{q+63}·{10}^{-k-1}+2^{64}·n\in \left(4,2^{64}-2\right)\hfill \end{array}$$

(129)

Suppose there are two real numbers a and b, and the following relationship must exist:

$$\begin{array}{cc}\hfill a-1& <\lfloor a\rfloor ⩽a\hfill \\ \hfill b-1& <\lfloor b\rfloor ⩽b\hfill \\ \hfill a+b-2& <\lfloor a\rfloor +\lfloor b\rfloor ⩽a+b\hfill \end{array}$$

(130)

When $a=2^{q+35}·{10}^{-k-1}$ and $b=2^{36}·n$ or $a=2^{q+63}·{10}^{-k-1}$ and $b=2^{64}·n$, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\lfloor 2^{36}·n\rfloor ⩽2^{q+35}·{10}^{-k-1}+2^{36}·n\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +\lfloor 2^{64}·n\rfloor ⩽2^{q+63}·{10}^{-k-1}+2^{64}·n\hfill \end{array}$$

(131)

From Equation (129), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\lfloor 2^{36}·n\rfloor <2^{36}-2^7\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +\lfloor 2^{64}·n\rfloor <2^{64}-2\hfill \end{array}$$

(132)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& ⩽\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +1\hfill \\ \hfill & <2^{36}-2-\lfloor 2^{36}·n\rfloor \hfill \\ \hfill & <2^{36}-1-\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& <2^{36}-1-\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \mathrm{double}:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& ⩽\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +1\hfill \\ \hfill & <2^{64}-2-\lfloor 2^{64}·n\rfloor \hfill \\ \hfill & <2^{64}-1-\lfloor 2^{64}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& <2^{64}-1-\lfloor 2^{64}·n_r\rfloor \hfill \end{array}$$

(133)

Therefore, when $2^{-1}·2^q·{10}^{-k-1}<1-n$, the condition (116) can be used to determine that $one\ne 10$.

(4)When $2^{-1}·2^q·{10}^{-k-1}>1-n$, there must exist $one=10$, and there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-1}·2^q·{10}^{-k-1}+n=n^{+}+1\in \left(1+2^{-33},2-2^{-29}\right)\hfill \\ \hfill \mathrm{double}:& 2^{-1}·2^q·{10}^{-k-1}+n=n^{+}+1\in \left(1+2^{-62},2-2^{-63}\right)\hfill \end{array}$$

(134)

Therefore, the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{q+35}·{10}^{-k-1}+2^{36}·n\in \left(2^3+2^{36},2^{37}-2^7\right)\hfill \\ \hfill \mathrm{double}:& 2^{q+63}·{10}^{-k-1}+2^{64}·n\in \left(4+2^{64},2^{65}-2\right)\hfill \end{array}$$

(135)

When $a=2^{q+35}·{10}^{-k-1}$ and $b=2^{36}·n$ or $a=2^{q+63}·{10}^{-k-1}$ and $b=2^{64}·n$, from Equation (130), the following exists:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\lfloor 2^{36}·n\rfloor >2^{q+35}·{10}^{-k-1}+2^{36}·n-2\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +\lfloor 2^{64}·n\rfloor >2^{q+63}·{10}^{-k-1}+2^{64}·n-2\hfill \end{array}$$

(136)

From Equation (135), we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\lfloor 2^{36}·n\rfloor >2^{36}+2^3-2>2^{36}\hfill \\ \hfill \mathrm{double}:& \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +\lfloor 2^{64}·n\rfloor >2^{64}+2-2>2^{64}\hfill \end{array}$$

(137)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& ⩾\lfloor 2^{q+35}·{10}^{-k-1}\rfloor \hfill \\ \hfill & >2^{36}-\lfloor 2^{36}·n\rfloor \hfill \\ \hfill & >2^{36}-1-\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& >2^{36}-1-\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill \mathrm{double}:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& ⩾\lfloor 2^{q+63}·{10}^{-k-1}\rfloor \hfill \\ \hfill & >2^{64}-\lfloor 2^{64}·n\rfloor \hfill \\ \hfill & >2^{64}-1-\lfloor 2^{64}·n_r\rfloor \hfill \\ \hfill \Rightarrow \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& >2^{64}-1-\lfloor 2^{64}·n_r\rfloor \hfill \end{array}$$

(138)

Therefore, when $2^{-1}·2^q·{10}^{-k-1}>1-n$, the condition (116) can be used to determine that $one=10$.

From the above proof, it can be seen that when condition (62) is met, the condition (116) can be used to determine whether $one=0$ or $one=10$ when $2^{-1}·2^q·{10}^{-k-1}=n$ or $2^{-1}·2^q·{10}^{-k-1}=1-n$. When $2^{-1}·2^q·{10}^{-k-1}>n$ or $2^{-1}·2^q·{10}^{-k-1}>1-n$, the condition (116) can be used to determine whether $one=0$ or $one=10$. When $2^{-1}·2^q·{10}^{-k-1}<n$ or $2^{-1}·2^q·{10}^{-k-1}<1-n$, the condition (116) can be used to determine whether $one\ne 0$ or $one\ne 10$.

The proof process of this section is completed. In the code implementation, the two judgment conditions can be quickly calculated using addition and subtraction shift operations, and can be compiled by the compiler into cmov instructions, thereby reducing the impact of branch prediction failure on performance.

Ultimately, we reached the following conclusion: $one$ can quickly determine whether $one$ equals 0 or 10 by using the following method.

$$\begin{array}{cc}\hfill \mathrm{float}:\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& >\lfloor 2^{36}·n_r\rfloor \Rightarrow one=0\hfill \\ \hfill \lfloor 2^{q+35}·{10}^{-k-1}\rfloor +even& >2^{36}-1-\lfloor 2^{36}·n_r\rfloor \Rightarrow one=10\hfill \\ \hfill \mathrm{double}:\lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& >\lfloor 2^{64}·n_r\rfloor \Rightarrow one=0\hfill \\ \hfill \lfloor 2^{q+63}·{10}^{-k-1}\rfloor +even& >2^{64}-1-\lfloor 2^{64}·n_r\rfloor \Rightarrow one=10\hfill \end{array}$$

(139)

3.7. Efficient Computation of $\lfloor 10n\rfloor$ and Rounding

Determine whether $one$ is $\lfloor 10n\rfloor$ or $\lfloor 10n\rfloor +1$ based on the decimal part of $10n$. There are two cases: the decimal part of $10n$ is 0.5 and it is not 0.5.

3.7.1. $10n-\lfloor 10n\rfloor =0.5$

When the decimal part of $10n$ is 0.5, there must be:

$$\begin{array}{c}\hfill 10n-\lfloor 10n\rfloor =0.5\\ \hfill \Rightarrow 10·c·2^q·{10}^{-k-1}-\lfloor 10·c·2^q·{10}^{-k-1}\rfloor =0.5\\ \hfill \Rightarrow c·2^q·{10}^{-k}-\lfloor c·2^q·{10}^{-k}\rfloor =0.5\\ \hfill \Rightarrow c·2^q·{10}^{-k}=\lfloor c·2^q·{10}^{-k}\rfloor +0.5\\ \hfill \Rightarrow 2c·2^q·{10}^{-k}=2\lfloor c·2^q·{10}^{-k}\rfloor +1\end{array}$$

(140)

So $2c·2^q·{10}^{-k}$ is an odd number. Then the following expression is odd:

$$\begin{array}{c}\hfill c·2^{q+1}·{10}^{-k}=c·2^{q-k+1}·5^{-k}\end{array}$$

(141)

According to the range of q, there are:

$$\begin{array}{c}\hfill c·2^{q+1}·{10}^{-k}=\left\{\begin{array}{c}{\displaystyle \frac{c·2^{q-k+1}}{5^k}};q⩾0\\ c·2·5^{-k};q=-1\\ {\displaystyle \frac{c·5^{-k}}{2^{k-q-1}}};q⩽-2\end{array}\right.\end{array}$$

(142)

According to the range of q, the following situations are discussed:

• $q⩾0$
  When $q⩾0$, it can be concluded that $q-k+1⩾1$, the numerator $c·2^{q-k+1}$ is even and the denominator $5^k$ is odd, which does not meet the condition.
• $q=-1$
  When $q=-1$, it can be concluded that $c·2·5^{-k}$ is even, which does not meet the condition.
• $q⩽-2$
  $5^{-k}$ is an odd number. c is an odd multiple of $2^{k-q-1}$. So:

  $$\begin{array}{cc}\hfill \mathrm{float}:& c⩾2^{k-q-1}\Rightarrow k-q-1⩽22\Rightarrow q⩾-34\hfill \\ \hfill \mathrm{double}:& c⩾2^{k-q-1}\Rightarrow k-q-1⩽51\Rightarrow q⩾-75\hfill \end{array}$$

  (143)
  Therefore, when q meets the above conditions, c must be an odd multiple of $2^{k-q-1}$ to meet the condition. Therefore, when the following conditions are met, expression (141) is an odd number:

  $$\begin{array}{cc}\hfill \mathrm{float}:& -34⩽q⩽-2\&\&c\%2^{k-q}=2^{k-q-1}\hfill \\ \hfill \mathrm{double}:& -75⩽q⩽-2\&\&c\%2^{k-q}=2^{k-q-1}\hfill \end{array}$$

  (144)
  When q is within the above range (144), $r=1$ is derived from Equation (28).Therefore, there is:

  $$\begin{array}{c}\hfill n_r=n\end{array}$$

  (145)
  The following equation holds:

  $$\begin{array}{c}\hfill 20m+20n=c·2^q·{10}^{-k+1}=c·2^{q-k+1}·5^{-k}={\displaystyle \frac{c}{2^{k-q-1}}}·5^{-k}\end{array}$$

  (146)
  Since $-k⩾1$ , $5^{-k}$ is multiple of 5 and is an odd number. Since ${\displaystyle \frac{c}{2^{k-q-1}}}$ and $5^{-k}$ are both odd numbers, $20m$ is an even number, $20n$ is multiple of 5 and is an odd number. Therefore, there is:

  $$\begin{array}{c}\hfill 20n\in \left\{5,15\right\}\\ \hfill \Rightarrow n\in \left\{0.25,0.75\right\}\\ \hfill \Rightarrow n_r\in \left\{0.25,0.75\right\}\end{array}$$

  (147)
  The result of $one$ is an even number between $\lfloor 10n\rfloor$ and $\lfloor 10n\rfloor +1$. Therefore:

  $$\begin{array}{c}\hfill one=\left\{\begin{array}{c}\lfloor 10n\rfloor =2,\mathrm{if}n=0.25\\ \lfloor 10n\rfloor +1=8,\mathrm{if}n=0.75\end{array}\right.\Rightarrow one=\lfloor 20n+1\rfloor //2-(n=0.25?1:0)\end{array}$$

  (148)

3.7.2. $10n-\lfloor 10n\rfloor \ne 0.5$

When the decimal part of $10n$ is not 0.5, round to the nearest integer value based on the decimal part of $10n$. Therefore, there is:

$$\begin{array}{c}\hfill one=\left\{\begin{array}{c}\lfloor 10n\rfloor ,\mathrm{if}10n-\lfloor 10n\rfloor <0.5\\ \lfloor 10n\rfloor +1,\mathrm{if}10n-\lfloor 10n\rfloor >0.5\end{array}\right.\Rightarrow one=\lfloor 10n+0.5\rfloor =\lfloor 20n+1\rfloor //2\end{array}$$

(149)

Since $\lfloor 20n+1\rfloor =\lfloor 20n\rfloor +1$, it is only necessary to accurately calculate the value of $\lfloor 20n\rfloor$. And, there is:

$$\begin{array}{cc}\hfill d& =ten+one\hfill \\ \hfill & =10m+\lfloor 20n+1\rfloor //2\hfill \\ \hfill & =(\lfloor 20m+20n\rfloor +1)//2\hfill \end{array}$$

(150)

Suppose there are:

$$\begin{array}{c}\hfill 20m+20n=c·2^{q+1}·{10}^{-k}=c·2^{q-k+1}·5^{-k}=c·{\displaystyle \frac{x}{y}}\end{array}$$

(151)

Suppose the decimal part of $20n$ is $n_{20}$.

When $y⩽c_{max}=C$, the range of the decimal part must include:

$$\begin{array}{cc}\hfill \mathrm{float}:& {\displaystyle \frac{1}{2^{24}-1}}={\displaystyle \frac{1}{C}}⩽n_{20}⩽1-{\displaystyle \frac{1}{C}}={\displaystyle \frac{2^{24}-2}{2^{24}-1}}\hfill \\ \hfill \mathrm{double}:& {\displaystyle \frac{1}{2^{53}-1}}={\displaystyle \frac{1}{C}}⩽n_{20}⩽1-{\displaystyle \frac{1}{C}}={\displaystyle \frac{2^{53}-2}{2^{53}-1}}\hfill \end{array}$$

(152)

When $y>c_{max}=C$, the range of the decimal part must include(the test file is test5.py):

$$\begin{array}{cc}\hfill \mathrm{float}:& 2^{-32}<n_{20}<1-2^{-30}\hfill \\ \hfill \mathrm{double}:& 2^{-64}<n_{20}<1-2^{-62}\hfill \end{array}$$

(153)

Therefore, the range of $n_{20}$ satisfies Equation (153). In the code implementation, for float, only the high 36 bits of $n_r$ are retained, and for double, only the high 70 bits of $n_r$ are retained. Suppose the discarded part of a float is represented as $n_{36}$, and similarly, the discarded part of a double is represented as $n_{70}$. Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& n_{36}\in \left[0,\left.2^{-36}\right)\right.\hfill \\ \hfill \mathrm{double}:& n_{70}\in \left[0,\left.2^{-70}\right)\right.\hfill \end{array}$$

(154)

Calculate the boundary conditions of the following expression:

$$\begin{array}{cc}\hfill \mathrm{float}:& F=20·\left(c·2^q·r·{10}^{-k-1}-n_{36}\right)\hfill \\ \hfill \mathrm{double}:& F=20·\left(c·2^q·r·{10}^{-k-1}-n_{70}\right)\hfill \end{array}$$

(155)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:F_{min}& >20·\left(c·2^q·{10}^{-k-1}-2^{-36}\right)\hfill \\ \hfill & =20m+20n-20·2^{-36}\hfill \\ \hfill F_{max}& <20·\left(c·2^q·\left(1+2^{-63}\right)·{10}^{-k-1}-0\right)\hfill \\ \hfill & <20m+20n+20·2^{-63}·c\hfill \\ \hfill & <20m+\lfloor 20n\rfloor +1\hfill \\ \hfill \mathrm{double}:F_{min}& >20·\left(c·2^q·{10}^{-k-1}-2^{-70}\right)\hfill \\ \hfill & =20m+20n-20·2^{-70}\hfill \\ \hfill & >20m+\lfloor 20n\rfloor \hfill \\ \hfill F_{max}& <20·\left(c·2^q·\left(1+2^{-127}\right)·{10}^{-k-1}-0\right)\hfill \\ \hfill & <20m+20n+20·2^{-127}·c\hfill \\ \hfill & <20m+\lfloor 20n\rfloor +1\hfill \end{array}$$

(156)

Therefore, there is:

$$\begin{array}{cc}\hfill \mathrm{float}:& \lfloor F\rfloor =20m+\lfloor 20n\rfloor \hfill \\ \hfill \mathrm{double}:& \lfloor F\rfloor =20m+\lfloor 20n\rfloor \hfill \end{array}$$

(157)

In fact, in the above proof process, for float, $\lfloor F_{min}\rfloor \ne 20m+\lfloor 20n\rfloor$ may exist, but the code implementation has passed the exhaustive test, so this not-so-perfect proof process can be ignored. Therefore, the calculation of d can be simplified as follows:

$$\begin{array}{cc}\hfill d& =ten+one\hfill \\ \hfill & =(\lfloor F\rfloor +1)//2\hfill \\ \hfill & =(\lfloor 20·(c·2^q·r·{10}^{-k-1}-n_x)\rfloor +1)//2\hfill \end{array}$$

(158)

For the float range, $n_x=n_{36}$; for the double range, $n_x=n_{70}$.

3.7.3. Efficient Implementation of $n=0.25$ for Double

For double, quickly determine that $n==0.25$ in Equation (148).

When $n=0.25$,$\lfloor 2^{64}·n_r\rfloor =\lfloor 2^{64}·n\rfloor =2^{62}$. Therefore, the following condition can be used to quickly determine whether $n=0.25$:

$$\begin{array}{cc}\hfill \mathrm{double}:& n=0.25\mathrm{if}\lfloor 2^{64}·n_r\rfloor =2^{62}\hfill \end{array}$$

(159)

When $n\ne 0.25$,Calculate the range of the decimal part of the following expression:

$$\begin{array}{c}\hfill 4m+4n=c·2^{q+2}·{10}^{-k-1}\end{array}$$

(160)

Therefore, when Equation (160) is not an integer, we have(the test file is test6.py):

$$\begin{array}{c}\hfill 2^{-62}<4n-\lfloor 4n\rfloor <1-2^{-62}\end{array}$$

(161)

Calculate the two boundary cases of $4n$ that are closest to 1:

$$\begin{array}{c}\hfill \lfloor 4n\rfloor =0\Rightarrow 4n-0<1-2^{-62}\Rightarrow \lfloor 2^{64}·n\rfloor ⩽2^{62}-2\\ \hfill \lfloor 4n\rfloor =1\Rightarrow 4n-1>2^{-62}\Rightarrow \lfloor 2^{64}·n\rfloor ⩾2^{62}+1\end{array}$$

(162)

Then there are:

$$\begin{array}{c}\hfill \lfloor 2^{64}·n\rfloor \ne 2^{62}\&\&\lfloor 2^{64}·n\rfloor +1\ne 2^{62}\\ \hfill \Rightarrow \lfloor 2^{64}·n_r\rfloor \ne 2^{62}\end{array}$$

(163)

Therefore, the following condition can be used to quickly determine whether $n\ne 0.25$:

$$\begin{array}{cc}\hfill \mathrm{double}:& n\ne 0.25\mathrm{if}\lfloor 2^{64}·n_r\rfloor \ne 2^{62}\hfill \end{array}$$

(164)

In summary, for double, the following condition can be used to quickly determine whether $n=0.25$:

$$\begin{array}{cc}\hfill \mathrm{double}:& n=0.25\mathrm{if}\lfloor 2^{64}·n_r\rfloor =2^{62}\hfill \\ \hfill \mathrm{double}:& n\ne 0.25\mathrm{if}\lfloor 2^{64}·n_r\rfloor \ne 2^{62}\hfill \end{array}$$

(165)

3.7.4. Efficient Calculation of $one$ for Double

In the double range, introduce another faster way to calculate $one$:

$$\begin{array}{cc}\hfill \mathrm{double}:& one=\lfloor {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10+\left(\left(n=0.25\right)?0:\left(2^{-1}+{\displaystyle \frac{6}{2^{64}}}\right)\right)\rfloor \hfill \end{array}$$

(166)

The proof of Equation (166) is as follows:

when $n=0.25$, $\lfloor {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10\rfloor =\lfloor 10n\rfloor =2$;

when $n\ne 0.25$, Equation (166) can be equivalent to the following:

$$\begin{array}{cc}\hfill \mathrm{double}:& one=\lfloor {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10+2^{-1}+{\displaystyle \frac{6}{2^{64}}}\rfloor \hfill \end{array}$$

(167)

According to the $10n-\lfloor 10n\rfloor$ range, $one$ is represented as:

$$\begin{array}{cc}\hfill \mathrm{double}:& one=\left\{\begin{array}{c}\lfloor 10n\rfloor ,\mathrm{if}10n-\lfloor 10n\rfloor <0.5\\ 8,\mathrm{if}10n-\lfloor 10n\rfloor =0.5\\ \lfloor 10n\rfloor +1,\mathrm{if}10n-\lfloor 10n\rfloor >0.5\end{array}\right.=\lfloor 20n+1\rfloor //2\hfill \end{array}$$

(168)

Therefore,when $n\ne 0.25$, we need to prove that the following equation holds:

$$\begin{array}{c}\hfill \lfloor {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10+2^{-1}+{\displaystyle \frac{6}{2^{64}}}\rfloor =\left\{\begin{array}{c}\lfloor 10n\rfloor ,\mathrm{if}10n-\lfloor 10n\rfloor <0.5\\ 8,\mathrm{if}10n-\lfloor 10n\rfloor =0.5\\ \lfloor 10n\rfloor +1,\mathrm{if}10n-\lfloor 10n\rfloor >0.5\end{array}\right.=\lfloor 20n+1\rfloor //2\end{array}$$

(169)

From the range of n, there is:

$$\begin{array}{c}\hfill {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}\in \left(n_r-2^{-64},n_r\right]\end{array}$$

(170)

Because the following conditions exist:

$$\begin{array}{cc}\hfill c·2^q·{10}^{-k-1}& =m+n\hfill \\ \hfill c·2^q·r·{10}^{-k-1}& =m+n_r\hfill \end{array}$$

(171)

Therefore, the following relationship can be concluded:

$$\begin{array}{cc}\hfill n_r-n& =\left(r-1\right)·c·2^q·{10}^{-k-1}\hfill \\ \hfill n_r& =\left(r-1\right)·\left(m+n\right)+n\hfill \\ \hfill \Rightarrow n⩽n_r& <2^{-127}·c+n\hfill \\ \hfill n⩽n_r& <2^{-127}·2^{53}+n\hfill \\ \hfill n⩽n_r& <2^{-74}+n\hfill \end{array}$$

(172)

From Equation (170) and (172), it can be concluded that:

$$\begin{array}{c}\hfill {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}\in \left(n-2^{-64},n+2^{-74}\right)\\ \hfill \Rightarrow {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10\in \left(10n-10·2^{-64},10n+10·2^{-74}\right)\\ \hfill \Rightarrow {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·20\in \left(20n-20·2^{-64},20n+20·2^{-74}\right)\\ \hfill \Rightarrow {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·20\in \left(\lfloor 20n\rfloor +n_{20}-20·2^{-64},\lfloor 20n\rfloor +n_{20}+20·2^{-74}\right)\end{array}$$

(173)

Discuss the range of values of x when the following conditions are met.

$$\begin{array}{c}\hfill \lfloor {\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·20+1+x\rfloor //2=\lfloor 20n+1\rfloor //2=one\end{array}$$

(174)

Therefore, the following conclusions can be drawn:

$$\begin{array}{cc}\hfill \lfloor 20n\rfloor +n_{20}-20·2^{-64}+1+x⩾\lfloor 20n+1\rfloor & \Rightarrow x⩾20·2^{-64}-n_{20}\hfill \\ \hfill \lfloor 20n\rfloor +n_{20}+20·2^{-74}+1+x<\lfloor 20n+2\rfloor & \Rightarrow x<1-20·2^{-74}-n_{20}\hfill \end{array}$$

(175)

Suppose $x=12·2^{-64}$. Through the exhaustive method, all floating-point numbers that do not meet the following conditions can be obtained.

$$\begin{array}{c}\hfill x=12·2^{-64}⩾20·2^{-64}-n_{20}\end{array}$$

(176)

All floating-point numbers that do not meet condition (176) are as follows (in hexadecimal) :

$$\begin{array}{cc}\hfill 0xd17c0747bd76fa1& ,\hfill \\ \hfill 0xd27c0747bd76fa1& ,\hfill \\ \hfill 0x4d73de005bd620df& ,\hfill \\ \hfill 0x4d83de005bd620df& ,\hfill \\ \hfill 0x4d93de005bd620df& ,\hfill \end{array}$$

(177)

Through the exhaustive method, all floating-point numbers that do not meet the following conditions can be obtained.

$$\begin{array}{c}\hfill x=12·2^{-64}<1-20·2^{-74}-n_{20}\end{array}$$

(178)

All floating-point numbers that do not meet condition (178) are as follows (in hexadecimal) :

$$\begin{array}{cc}\hfill 0x612491daad0ba280& ,\hfill \\ \hfill 0x6159b651584e8b20& ,\hfill \\ \hfill 0x619011f2d73116f4& ,\hfill \\ \hfill 0x61c4166f8cfd5cb1& ,\hfill \\ \hfill 0x61d4166f8cfd5cb1& ,\hfill \end{array}$$

(179)

There are:

$$\begin{array}{c}\hfill 2({\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10+2^{-1}+{\displaystyle \frac{6}{2^{64}}})={\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·20+1+x\end{array}$$

(180)

When the floating-point number is not within the above range (177) and (179), the condition (175) is satisfied. We have tested all floating-point numbers within the above-mentioned range (177) and (179), and the algorithm implementation code has output the correct result, that is, it satisfies the SW principle. The test process file is test8.py.

In summary, Equation (169) and Equation (166) holds. Therefore, Equation (166) can be used to quickly calculate $one$.

3.8. Irregular Number

Due to the limited and small number of irregular floating-point numbers, there are a total of 2046 double floating-point numbers and 254 float floating-point numbers. The correctness of the algorithm code in this paper can be proved by the exhaustive method. Therefore, it is not introduced in this article. For the specific implementation process, please refer to the source code.

3.9. Implementation of Pseudocode

This subsection details the pseudocode implementation for converting regular floating-point numbers to decimal representation. The handling of subnormal (irregular) floating-point numbers is omitted here due to space constraints; interested readers may refer to the source code for the complete implementation.

3.9.1. Single-Precision Floating-Point Numbers

$$\begin{array}{cc}\hfill \mathrm{uint}32vi& =\mathrm{bit}\_\mathrm{copy}\_\mathrm{from}\_\mathrm{f}32\left(v\right)\hfill \\ \hfill (\mathrm{uint}64c,\mathrm{int}32q)& =\mathrm{extract}\left(vi\right)\hfill \\ \hfill \mathrm{const}\mathrm{int}\mathrm{BIT}& =36\hfill \\ \hfill \mathrm{const}\mathrm{uint}64\mathrm{offset}& =(1\mathrm{ULL}\ll (\mathrm{BIT}-2\left)\right)-7\hfill \\ \hfill \mathrm{int}32k& =(q·1233)\gg 12\hfill \\ \hfill \mathrm{int}32h& =q+\left(\right(1701·(-k-1))\gg 9)\hfill \\ \hfill \mathrm{uint}64\mathrm{pow}10& =\mathrm{get}\_\mathrm{pow}10(-k-1)\hfill \\ \hfill \mathrm{uint}64cb& =c\ll (h+\mathrm{BIT}+1)\hfill \\ \hfill \mathrm{uint}64\mathrm{hi}64& =\mathrm{umul}\_{\mathrm{hi}}_{64\times 64}(cb,\mathrm{pow}10)\hfill \\ \hfill \mathrm{bool}\mathrm{even}& =(vi+1)\&1\hfill \\ \hfill \mathrm{uint}64\mathrm{half}& =(\mathrm{pow}10\gg (65-(h+\mathrm{BIT}+1)\left)\right)+\mathrm{even}\hfill \\ \hfill \mathrm{uint}32\mathrm{shorter}& =(\mathrm{hi}64+\mathrm{half})\gg \mathrm{BIT}\hfill \\ \hfill \mathrm{uint}64\mathrm{bias}& =(\mathrm{hi}64\gg (\mathrm{BIT}-4\left)\right)\&15\hfill \\ \hfill \mathrm{uint}32\mathrm{longer}& =(5·\mathrm{hi}64+\mathrm{offset}+\mathrm{bias})\gg (\mathrm{BIT}-1)\hfill \\ \hfill \mathrm{bool}\mathrm{updown}& =\mathrm{shorter}>\left(\right(\mathrm{hi}64-\mathrm{half})\gg \mathrm{BIT})\hfill \\ \hfill \mathrm{uint}32d& =\mathrm{updown}?\mathrm{shorter}·10:\mathrm{longer}\hfill \end{array}$$

(181)

Algorithm 181 outlines the procedure for computing d and k for single-precision floating-point numbers.

Since c contains at most 23 significant bits and $\mathrm{pow}10$ has 64 significant bits, their product contains at most 87 significant bits. Given that the range of h is $[-4,-1]$, the value $cb=c\ll (h+\mathrm{BIT}+1)$ does not overflow, preserving all bits of c. When $e_{10}=-k-1$, $\mathrm{pow}10$ is computed using Equation (24). From Equation (25), we derive:

$$\begin{array}{c}\hfill \mathrm{pow}10·2^{\lfloor (-k-1)·{log}_{2}10\rfloor -63}={10}^{-k-1}·r_{1,-k-1}\end{array}$$

(182)

From Equation (51):

$$\begin{array}{cc}\hfill m& =\lfloor v·{10}^{-k-1}\rfloor \hfill \\ \hfill & =\lfloor v·{10}^{-k-1}·r_{1,-k-1}\rfloor \hfill \\ \hfill & =\lfloor v·\mathrm{pow}10·2^{\lfloor (-k-1)·{log}_{2}10\rfloor -63}\rfloor \hfill \\ \hfill & =\lfloor c·\mathrm{pow}10·2^{q+\lfloor (-k-1)·{log}_{2}10\rfloor -63}\rfloor \hfill \\ \hfill & =(c·\mathrm{pow}10)\gg (63-q-\lfloor (-k-1)·{log}_{2}10\rfloor )\hfill \\ \hfill & =(c·\mathrm{pow}10)\gg (63-h)\hfill \\ \hfill & =\left(\right(c\ll (37+h))·\mathrm{pow}10)\gg (36+64)\hfill \\ \hfill & =\mathrm{hi}64\gg 36\hfill \end{array}$$

(183)

Let $\mathrm{up}$ indicate whether $one=10$. From Equations (138) and (105):

$$\begin{array}{cc}\hfill \mathrm{bool}\mathrm{up}& =\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\mathrm{even}>2^{36}-1-\lfloor 2^{36}·n_r\rfloor \hfill \\ \hfill & =\lfloor 2^{q+35}·{10}^{-k-1}\rfloor +\mathrm{even}+\lfloor 2^{36}·n_r\rfloor ⩾2^{36}\hfill \\ \hfill & =(\mathrm{pow}10\gg (28-h))+\mathrm{even}+\lfloor 2^{36}·n_r\rfloor ⩾2^{36}\hfill \\ \hfill & =(\mathrm{half}+\lfloor 2^{36}·n_r\rfloor )\gg 36\hfill \end{array}$$

(184)

When $one\ne 10$, we have $d//10=m$; when $one=10$, we have $d//10=m+1$. Therefore:

$$\begin{array}{c}\hfill d//10=m+\mathrm{up}\end{array}$$

(185)

The upper 28 bits of $\mathrm{hi}64$ represent m, while the lower 36 bits represent $\lfloor 2^{36}·n_r\rfloor$:

$$\begin{array}{c}\hfill \mathrm{hi}64=(m\ll 36)+\lfloor 2^{36}·n_r\rfloor \end{array}$$

(186)

Consequently:

$$\begin{array}{c}\hfill \mathrm{shorter}=d//10=(\mathrm{hi}64+\mathrm{half})\gg 36\end{array}$$

(187)

Let $\mathrm{updown}$ indicate whether $one\in \{0,10\}$, equivalently whether the last digit of d is zero:

$$\begin{array}{c}\hfill \mathrm{updown}=(dmod10=0)\end{array}$$

(188)

For brevity, let $\mathrm{dot}\_\mathrm{one}=\lfloor 2^{36}·n_r\rfloor$. From Equations (134) and (140):

$$\begin{array}{cc}\hfill one=0& :\mathrm{half}>\mathrm{dot}\_\mathrm{one}\hfill \\ \hfill one=10& :\mathrm{half}>2^{36}-1-\mathrm{dot}\_\mathrm{one}\hfill \end{array}$$

(189)

The following equations hold:

$$\begin{array}{cc}\hfill one=0& :(\mathrm{hi}64-\mathrm{half})\gg 36=m-1\hfill \\ \hfill one=10& :(\mathrm{hi}64-\mathrm{half})\gg 36=m\hfill \end{array}$$

(190)

Therefore:

$$\begin{array}{cc}\hfill one=0& :\mathrm{shorter}=m>(\mathrm{hi}64-\mathrm{half})\gg 36=m-1\hfill \\ \hfill one=10& :\mathrm{shorter}=m+1>(\mathrm{hi}64-\mathrm{half})\gg 36=m\hfill \end{array}$$

(191)

Thus, the condition for $one\in \{0,10\}$ is:

$$\begin{array}{c}\hfill \mathrm{shorter}>(\mathrm{hi}64-\mathrm{half})\gg 36\Rightarrow dmod10=0\end{array}$$

(192)

When $\mathrm{updown}$ is true, $d=10·\mathrm{shorter}$. Otherwise, we compute d using Equation (158). When $10n-\lfloor 10n\rfloor \ne 0.5$:

$$\begin{array}{cc}\hfill d& =(\lfloor 20·(v·{10}^{-k-1}·r-n_{36})\rfloor +1)//2\hfill \\ \hfill & =(\lfloor 20·(\mathrm{hi}64·2^{-36})\rfloor +1)//2\hfill \\ \hfill & =(\lfloor 5·\mathrm{hi}64·2^{-34}\rfloor +1)//2\hfill \\ \hfill & =\left(\lfloor (5·\mathrm{hi}64+2^{34})·2^{-34}\rfloor \right)//2\hfill \\ \hfill & =((5·\mathrm{hi}64+2^{34})\gg 34)//2\hfill \\ \hfill & =(5·\mathrm{hi}64+2^{34})\gg 35\hfill \end{array}$$

(193)

Adding $2^{34}$ serves as a rounding operation. When $10n-\lfloor 10n\rfloor =0.5$, Equation (148) requires checking whether $n=0.25$. The derivation of $\mathrm{longer}$ involves careful handling of edge cases; the correctness of this computation has been verified through exhaustive testing.

3.9.2. Double-Precision Floating-Point Numbers

$$\begin{array}{cc}\hfill \mathrm{uint}64vi& =\mathrm{bit}\_\mathrm{copy}\_\mathrm{from}\_\mathrm{f}64\left(v\right)\hfill \\ \hfill (\mathrm{uint}64c,\mathrm{int}q)& =\mathrm{extract}\left(vi\right)\hfill \\ \hfill \mathrm{const}\mathrm{int}\mathrm{BIT}& =6\hfill \\ \hfill \mathrm{int}k& =(q·78913)\gg 18\hfill \\ \hfill \mathrm{int}h& =q+\left(\right(217707·(-k-1))\gg 16)\hfill \\ \hfill \mathrm{uint}128\mathrm{pow}10& =\mathrm{get}\_\mathrm{pow}10(-k-1)\hfill \\ \hfill \mathrm{uint}64cb& =c\ll (h+\mathrm{BIT}+1)\hfill \\ \hfill \mathrm{uint}128\mathrm{hi}128& =\mathrm{umul}\_{\mathrm{hi}}_{64\times 128}(cb,\mathrm{pow}10)\hfill \\ \hfill \mathrm{bool}\mathrm{even}& =(vi+1)\&1\hfill \\ \hfill \mathrm{uint}64\mathrm{half}& =(\mathrm{pow}10\gg (64-h\left)\right)+\mathrm{even}\hfill \\ \hfill \mathrm{uint}64\mathrm{dot}\_\mathrm{one}& =\left(\mathrm{uint}64\right)(\mathrm{hi}128\gg \mathrm{BIT})\hfill \\ \hfill \mathrm{uint}64\mathrm{ten}& =10·(\mathrm{hi}128\gg (\mathrm{BIT}+64\left)\right)\hfill \\ \hfill \mathrm{uint}64\mathrm{offset}\_\mathrm{num}& =(\mathrm{dot}\_\mathrm{one}==2^{62})?0:2^{63}+6\hfill \\ \hfill \mathrm{uint}64one& =\left(\right(\mathrm{uint}128)10·\mathrm{dot}\_\mathrm{one}+\mathrm{offset}\_\mathrm{num})\gg 64\hfill \\ \hfill one& =(\mathrm{half}>\mathrm{dot}\_\mathrm{one})?0:one\hfill \\ \hfill one& =(\mathrm{half}>2^{64}-1-\mathrm{dot}\_\mathrm{one})?10:one\hfill \\ \hfill \mathrm{uint}64d& =\mathrm{ten}+one\hfill \end{array}$$

(194)

Algorithm 194 presents the corresponding procedure for double-precision floating-point numbers. $\mathrm{pow}10$ is computed using Equation (26), satisfying:

$$\begin{array}{c}\hfill \mathrm{pow}10·2^{\lfloor (-k-1)·{log}_{2}10\rfloor -127}={10}^{-k-1}·r_{1,-k-1}\end{array}$$

(195)

From Equation (51):

$$\begin{array}{cc}\hfill m& =\lfloor v·{10}^{-k-1}\rfloor \hfill \\ \hfill & =\lfloor v·{10}^{-k-1}·r_{1,-k-1}\rfloor \hfill \\ \hfill & =\lfloor v·\mathrm{pow}10·2^{\lfloor (-k-1)·{log}_{2}10\rfloor -127}\rfloor \hfill \\ \hfill & =\lfloor c·\mathrm{pow}10·2^{q+\lfloor (-k-1)·{log}_{2}10\rfloor -127}\rfloor \hfill \\ \hfill & =(c·\mathrm{pow}10)\gg (127-q-\lfloor (-k-1)·{log}_{2}10\rfloor )\hfill \\ \hfill & =(c·\mathrm{pow}10)\gg (127-h)\hfill \\ \hfill & =\left(\right(c\ll (7+h))·\mathrm{pow}10)\gg (64+70)\hfill \\ \hfill & =\mathrm{hi}128\gg 70\hfill \end{array}$$

(196)

Given $h\in [-4,-1]$ and c having at most 53 significant bits, $cb$ does not overflow, ensuring accurate computation of $\mathrm{ten}=10·m$. By definition, $\mathrm{dot}\_\mathrm{one}=\lfloor 2^{64}·n_r\rfloor$. From Equation (105):

$$\begin{array}{cc}\hfill \mathrm{half}& =(\mathrm{pow}10\gg (64-h\left)\right)+\mathrm{even}\hfill \\ \hfill & =\lfloor 2^{63}·2^q·{10}^{-k-1}\rfloor +\mathrm{even}\hfill \end{array}$$

(197)

The value of $one$ is first computed using Equation (166), then adjusted if the conditions for $one=0$ or $one=10$ are met:

$$\begin{array}{cc}\hfill one& =⌊{\displaystyle \frac{\lfloor 2^{64}·n_r\rfloor }{2^{64}}}·10+\left((n=0.25)?0:(2^{-1}+{\displaystyle \frac{6}{2^{64}}})\right)⌋\hfill \\ \hfill & =(\mathrm{dot}\_\mathrm{one}·10+(\mathrm{dot}\_\mathrm{one}==2^{62}?0:2^{63}+6))\gg 64\hfill \end{array}$$

(198)

An equivalent formulation is:

$$\begin{array}{c}\hfill one=(\mathrm{dot}\_\mathrm{one}==2^{62})?2:(\mathrm{dot}\_\mathrm{one}·10+2^{63}+6)\gg 64\end{array}$$

(199)

The conditions $one=0$ and $one=10$ are determined by Equations (127) and (138), respectively.

In the C/C++ implementation, the only branch occurs when computing c and q for subnormal floating-point numbers (marked as $\mathrm{unlikely}$). The conversion of normal floating-point numbers is branch-free, eliminating branch misprediction penalties. As shown in Algorithms 181 and 194, the core algorithm is remarkably concise. Irregular numbers are handled in a separate branch—a worthwhile trade-off given their rarity.

3.10. Decimal to String Conversion

The floating-point number printing algorithm consists of two main phases. While the first phase, which computes the decimal digits d and exponent k, has been discussed in previous sections, this section focuses on the second phase: converting the computed decimal representation into a string.

Floating-point numbers are typically printed in two formats: fixed-point notation and scientific notation. Table (Table 3) illustrates examples of both formats.

Having computed d and k, we now convert the floating-point number to a string based on these values. According to the Schubfach algorithm, d may contain trailing zeros, meaning $dmod10$ could be zero. In order to reduce instruction dependencies. We decompose d into two parts: $d//10$ and $dmod10$. Let $up$ indicate whether $one$ equals 10, and $updown$ represent the cases where $one$ is either 0 or 10. The following relationships hold:

$$\begin{array}{cc}\hfill d//10& =m+up\hfill \\ \hfill updown& =(one=0\vee one=10)=(dmod10=0)\hfill \\ \hfill d& =10·(m+up)+(updown?0:one)\hfill \end{array}$$

(200)

By calculating the approximate range of m, we obtain:

$$\begin{array}{cc}\hfill m& =\lfloor c·2^q·{10}^{-k-1}\rfloor \hfill \\ \hfill c·2^q·{10}^{-k-1}& \in [0.1·c,c)\hfill \\ \hfill \Rightarrow \lfloor 0.1·c_{min}\rfloor ⩽\lfloor 0.1·c\rfloor ⩽& m⩽\lfloor c\rfloor ⩽\lfloor c_{max}\rfloor \hfill \end{array}$$

(201)

Based on the range of c, we derive:

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{c}\mathrm{normal}:[{\displaystyle \frac{2^{23}+1}{10}},2^{24}-1]=[838860.9,16777215]\hfill \\ \mathrm{subnormal}:[{\displaystyle \frac{1}{10}},2^{23}-1]=[0.1,8388607]\hfill \end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{c}\mathrm{normal}:[{\displaystyle \frac{2^{52}+1}{10}},2^{53}-1]=[4.5\times {10}^{14},9\times {10}^{15}]\hfill \\ \mathrm{subnormal}:[{\displaystyle \frac{1}{10}},2^{52}-1]=[0.1,4.5\times {10}^{15}]\hfill \end{array}\right.\hfill \end{array}$$

(202)

Let $len10\left(x\right)$ denote the number of decimal digits in x. For $x>0$:

$$len10\left(x\right)=\lfloor {log}_{10}\left(x\right)\rfloor +1$$

(203)

We define $len10\left(0\right)=0$. For example, $len10\left(12345\right)=5$. Consequently:

$$\begin{array}{cc}\hfill \mathrm{float}:& \left\{\begin{array}{c}\mathrm{normal}:len10(m+up)\in [6,8]\hfill \\ \mathrm{subnormal}:len10(m+up)\in [0,7]\hfill \end{array}\right.\hfill \\ \hfill \mathrm{double}:& \left\{\begin{array}{c}\mathrm{normal}:len10(m+up)\in [15,16]\hfill \\ \mathrm{subnormal}:len10(m+up)\in [0,16]\hfill \end{array}\right.\hfill \end{array}$$

(204)

Since $d//10=m+up$, we have $len10\left(d\right)=len10(m+up)+1$. Let $tz10\left(x\right)$ denote the number of trailing zeros in the decimal representation of x; for example, $tz10\left(12300\right)=2$. The number of significant digits $sig10\left(x\right)$ equals $len10\left(x\right)-tz10\left(x\right)$. When $updown=0$, $one\ne 0$, thus $dmod10=one\ne 0$ and $tz10\left(d\right)=0$. Therefore:

$$\begin{array}{cc}\hfill sig10\left(d\right)& =updown?len10\left(d\right)-tz10\left(d\right):len10\left(d\right)\hfill \\ \hfill \mathrm{float}:& sig10\left(d\right)\in [1,9]\hfill \\ \hfill \mathrm{double}:& sig10\left(d\right)\in [1,17]\hfill \end{array}$$

(205)

For normal floating-point numbers, $len10\left(d\right)$ can be computed as:

$$\begin{array}{cc}\hfill \mathrm{float}:& len10\left(d\right)=len(m+up)+1=9-[m+up<{10}^7]-[m+up<{10}^6]\hfill \\ \hfill \mathrm{double}:& len10\left(d\right)=len(m+up)+1=16+[(m+up)⩾{10}^{15}]\hfill \end{array}$$

(206)

where $\left[P\right]$ denotes the Iverson bracket, which evaluates to 1 if predicate P is true and 0 otherwise.

Computing the ASCII representation of d reduces to computing the ASCII codes of $m+up$ and $one$. From the above, we have:

$$\begin{array}{cc}\hfill \mathrm{float}:& m+up<{10}^8\hfill \\ \hfill \mathrm{double}:& m+up<{10}^{16}\hfill \end{array}$$

(207)

These bounds allow efficient computation of the ASCII code for $m+up$ using CPU SIMD instruction sets.

Scalar Implementation

We first present a scalar method that does not rely on SIMD instructions.

Let $x\in [0,{10}^8)$ and $dec\_to\_ascii8\left(x\right)$ be a function that computes the ASCII representation of x. Algorithm (2) describes this process. This version is an optimized version of the itoa algorithm written by Paul Khuong [18].

Algorithm 2:Convert an 8-digit decimal number to ASCII: dec_to_ascii8(x)

Input:  X (type: uint64, range: [0, ${10}^8$)) Output:  Y (type: uint64), tz (type: uint) 1: uint64 abcd_efgh = X + (0x100000000 - 10000) * ((X * 0x68db8bbULL) $>>$ 40) 2: uint64 ab_cd_ef_gh = abcd_efgh + (0x10000 - 100) * (((abcd_efgh * 0x147b) $>>$ 19) & 0x7f0000007f) 3: uint64 a_b_c_d_e_f_g_h = ab_cd_ef_gh + (0x100 - 10) * (((ab_cd_ef_gh * 0x67) $>>$ 10) & 0xf000f000f000f) 4: uint tz = __builtin_ctzll(a_b_c_d_e_f_g_h) $>>$ 3 5: uint64 BCD = CPU_IS_LITTLE_ENDIAN ? byteswap(a_b_c_d_e_f_g_h) : a_b_c_d_e_f_g_h 6: uint64 Y = BCD + 0x3030303030303030 return Y, tz

The function simultaneously computes $tz10\left(x\right)$ as the return value $tz$. Example: X = 12345600, Y="12345600", tz=2.

Algorithm 3:Convert a 16-digit decimal number to ASCII: dec_to_ascii16(x)

Input:  X (type: uint64, range: [0, ${10}^{16}$)) Output:  Y (type: uint128), tz (type: uint) 1: uint64 abcdefgh = X // ${10}^8$ 2: uint64 ijklmnop = X mod ${10}^8$ 3: (uint64 abcdefgh_ascii, uint tz1) = dec_to_ascii8(abcdefgh) 4: (uint64 ijklmnop_ascii, uint tz2) = dec_to_ascii8(ijklmnop) 5: uint128 Y = CPU_IS_LITTLE_ENDIAN ? (ijklmnop_ascii << 64) + abcdefgh_ascii : (abcdefgh_ascii << 64) + ijklmnop_ascii 6: uint tz = (ijklmnop == 0) ? 8 + tz1 : tz2 return Y, tz

For $x\in [0,{10}^{16})$, let $dec\_to\_ascii16\left(x\right)$ compute the ASCII representation of x. Algorithm (3) describes this process. Example: X = 123456001234500, Y="1234560012345600", tz=2.

Handling Undefined Behavior

Since $\_\_builtin\_ctzll\left(0\right)$ is undefined behavior in C, special handling is required. For single-precision floating-point numbers, when $m+up=0$ (the six smallest subnormal numbers), $updown=0$, avoiding the undefined case. For double-precision numbers, $m+up=0$ only occurs for $5\times {10}^{-324}$ (the smallest subnormal number). In our implementation, we handle this special case separately at the function entry.

SIMD Implementation

The SIMD implementations of $dec\_to\_ascii8$ and $dec\_to\_ascii16$ follow the same principles as the scalar version. For ARM64 architecture, we use the NEON instruction set; for x64 architecture, we support three variants: AVX512, SSE4.1, and SSE2. Table (Table 4) summarizes these implementations.

Using the methods above, we compute the ASCII representation of $m+up$ and the number of significant digits. Printing d is equivalent to printing $m+up$ and $one$. Based on $sig10\left(d\right)$, we determine which buffer contents to retain. In our implementation, we adopt different formats for floating-point numbers in different ranges to enhance readability, as shown in Table (Table 5).

In scientific notation, the result includes an exponent. For example, in “1.2e-02”, “e-02” represents the exponent. Converting $d·{10}^k$ to standard decimal scientific notation yields:

$$d·{10}^k=\left(d·{10}^{-\lfloor {log}_{10}\left(d\right)\rfloor }\right)·{10}^{k+\lfloor {log}_{10}\left(d\right)\rfloor }$$

(208)

Since $d·{10}^{-\lfloor {log}_{10}\left(d\right)\rfloor }\in [1,10)$, the exponent is determined by $k+\lfloor {log}_{10}\left(d\right)\rfloor$. Let $E_{10}=k+\lfloor {log}_{10}\left(d\right)\rfloor$. Then:

$$E_{10}=k+\lfloor {log}_{10}\left(d\right)\rfloor =k+\lfloor {log}_{10}(m+up)\rfloor +1$$

(209)

For single-precision floating-point numbers, fixed-point notation is used when $E_{10}\in [-3,6]$. For double-precision numbers, fixed-point notation is used when $E_{10}\in [-4,15]$.

The floating-point number printing algorithm proposed in this paper is illustrated as Algorithm 4. The key distinction between our algorithm and others is the use of SIMD instruction sets for converting $m+up$ to ASCII values. For single-precision numbers, we use $dec\_to\_ascii8$; for double-precision, we use $dec\_to\_ascii16$. The detailed implementation is available in the source code.

Algorithm 4:Floating-point number printing algorithm

Input:  v (type: float/double), buffer (type: char*) Output:  buffer (type: char*) 1: compute $m+up$, $updown$, $one$, k from v 2: compute $sig10\left(d\right)=updown?len10(m+up)-tz10(m+up):len10(m+up)+1$ 3: compute $E_{10}=k+\lfloor {log}_{10}(m+up)\rfloor +1$ 4: convert $m+up$, $one$ to ASCII codes and store in buffer 5: based on $sig10\left(d\right)$ and $E_{10}$, determine which buffer contents to retain 6: if result is in scientific notation, print $E_{10}$ return buffer

In our C implementation, all branches are designed as unlikely branches to minimize the impact of branch prediction failures. By transforming the computation of d into computing $m+up$ and $one$, we reduce instruction dependencies and enhance instruction-level parallelism. Unlike other algorithms that compute the exact value of d before printing, we avoid computing d directly and instead quickly compute $d//10=m+up$.

3.11. Summary

This chapter explains how to quickly calculate d and k, as well as the printing optimization. Since $d=10m+one$, the process of calculating d is transformed into calculating m and $one$.

• Section 3.5 introduces the method for quickly calculating m.
• Section 3.6 and Section 3.7 introduce the methods for quickly calculating $one$.
• Section 3.9 provides a detailed description of the pseudo-code implementation.
• Section 3.10 discusses print optimization.

Table 6. All algorithms in the benchmark test.

algorithm	float	double	description
Schubfach	Schubfach32	Schubfach64	author:Raffaello Giulietti,https://github.com/c4f7fcce9cb06515/Schubfach.
Schubfach_xjb	Schubfach32_xjb	Schubfach64_xjb	It is improved by Schubfach and has the same output result.
Ryu	Ryu32	Ryu64	author:Ulf Adams,https://github.com/ulfjack/ryu.
Dragonbox	Dragonbox32	Dragonbox64	author:Junekey Jeon,https://github.com/jk-jeon/Dragonbox.
fmt [22]	fmt32	fmt64	author:Victor Zverovich,https://github.com/fmtlib/fmt version:12.1.0
yy_double	-	yy_double	author:GuoYaoYuan,link:yy_double.
yy_json [23]	yy_json32	yy_json64	author:Guo YaoYuan,https://github.com/ibireme/yyjson version:0.12.0
teju_jagua [24]	teju32	teju64	author:Cassio Neri,https://github.com/cassioneri/teju_jagua.
xjb	xjb32	xjb64	this paper,https://github.com/xjb714/xjb.
zmij	zmij32	zmij64	author:Victor Zverovich,https://github.com/vitaut/zmij.
jnum [25]	jnum32	jnum64	author:Jing Leng,https://github.com/lengjingzju/json/jnum.c.
uscalec	-	uscalec	author:Russ Cox,src:https://github.com/rsc/fpfmt commit 6255750 (19 Jan 2026).

Table 6. All algorithms in the benchmark test.

algorithm	float	double	description
Schubfach	Schubfach32	Schubfach64	author:Raffaello Giulietti,https://github.com/c4f7fcce9cb06515/Schubfach.
Schubfach_xjb	Schubfach32_xjb	Schubfach64_xjb	It is improved by Schubfach and has the same output result.
Ryu	Ryu32	Ryu64	author:Ulf Adams,https://github.com/ulfjack/ryu.
Dragonbox	Dragonbox32	Dragonbox64	author:Junekey Jeon,https://github.com/jk-jeon/Dragonbox.
fmt [22]	fmt32	fmt64	author:Victor Zverovich,https://github.com/fmtlib/fmt version:12.1.0
yy_double	-	yy_double	author:GuoYaoYuan,link:yy_double.
yy_json [23]	yy_json32	yy_json64	author:Guo YaoYuan,https://github.com/ibireme/yyjson version:0.12.0
teju_jagua [24]	teju32	teju64	author:Cassio Neri,https://github.com/cassioneri/teju_jagua.
xjb	xjb32	xjb64	this paper,https://github.com/xjb714/xjb.
zmij	zmij32	zmij64	author:Victor Zverovich,https://github.com/vitaut/zmij.
jnum [25]	jnum32	jnum64	author:Jing Leng,https://github.com/lengjingzju/json/jnum.c.
uscalec	-	uscalec	author:Russ Cox,src:https://github.com/rsc/fpfmt commit 6255750 (19 Jan 2026).

4. Experimental Evaluation

This section presents a comprehensive experimental evaluation of the xjb algorithm, comparing its performance against state-of-the-art floating-point to string conversion algorithms across multiple hardware platforms and compilers.

4.1. Correctness Verification

Before conducting performance benchmarks, we verified the correctness of the xjb algorithm through extensive testing:

• Single-precision (float): We tested all possible input values ($2^{32}$ values) and verified that the output matches the Schubfach algorithm, ensuring complete correctness for the binary32 format.
• Double-precision (double): Due to the impracticality of exhaustively testing all $2^{64}$ possible values, we conducted comprehensive random testing with a large sample size to verify correctness for the binary64 format.

All test results confirmed that xjb produces output identical to Schubfach while satisfying the SW principle.

4.2. Experimental Setup

4.2.1. Hardware Platforms

We conducted benchmarks on two representative hardware platforms:

• AMD Ryzen 7 7840H: A modern x86-64 processor with support for AVX2 and AVX-512 instruction sets, running Ubuntu 26.04.
• Apple M1: A representative ARM-based processor with NEON SIMD support, running macOS 26.4.

4.2.2. Compilers and Compilation Flags

• AMD R7-7840H: Intel C++ Compiler (icpx) version 2025.0.4
• Apple M1: Apple Clang version 21.0.0

All benchmarks were compiled with the optimization flags -O3 -march=native to enable maximum compiler optimizations and architecture-specific instruction generation.

4.2.3. Benchmark Methodology

The benchmark methodology was designed to provide fair and reproducible performance measurements:

1.

Generate $2^{24}$ random floating-point numbers, excluding special values (0, NaN, and Inf).

2.

Measure the total time required to convert all numbers to decimal representation.

3.

Calculate the average conversion time per floating-point number.

This methodology ensures statistical significance while avoiding the overhead of special-case handling that would skew results.

4.3. Algorithms Compared

We compared xjb against the following state-of-the-art algorithms:

Table 7 and (Table 8) present the benchmark results for float-to-decimal and double-to-decimal conversions on AMD R7-7840H and Apple M1, respectively. Figure 1a–f presents the benchmark results for the conversion from float to string and from double to string. Figure 1a–d present the benchmark results when the input values are completely random. Since the significant digit length range of the printing results is from 1 to 17, comparative tests were also conducted for different effective lengths, as shown in Figure 1e,f.

• Schubfach: The baseline algorithm from which xjb is derived.
• Schubfach_xjb: A variant of Schubfach with xjb optimizations.
• Ryu: A widely-used high-performance algorithm.
• Dragonbox: Another state-of-the-art algorithm with competitive performance.
• fmt: A modern formatting library.
• yy_json / yy_double: Fast algorithms optimized for JSON serialization.
• teju_jagua: A recent algorithm (note: only supports float/double to decimal conversion).
• zmij: A modern algorithm with competitive performance.
• uscalec: An algorithm supporting double-precision only.

4.4. Performance Results

4.5. Analysis and Discussion

4.5.1. Performance Comparison

The benchmark results demonstrate that xjb achieves superior performance compared to all other algorithms across both hardware platforms:

On AMD R7-7840H:

• For float-to-decimal conversion, xjb achieves 2.24 ns, which is 1.98× faster than the second-fastest algorithm (Schubfach_xjb at 4.44 ns) and 5.44× faster than the baseline Schubfach (12.2 ns).
• For double-to-decimal conversion, xjb achieves 3.76 ns, which is 1.27× faster than the second-fastest algorithm (yy_double at 5.24 ns) and 3.06× faster than the baseline Schubfach (11.51 ns).
• For float-to-string conversion, xjb is about 60% faster than zmij.
• For double-to-string conversion, xjb is about 8% faster than zmij.

On Apple M1:

• For float-to-decimal conversion, xjb achieves 2.15 ns, which is 1.84× faster than the second-fastest algorithm (zmij at 4.11 ns) and 5.41× faster than the baseline Schubfach (11.64 ns).
• For double-to-decimal conversion, xjb achieves 2.58 ns, which is 1.49× faster than the second-fastest algorithm (yy_double at 4.08 ns) and 5.08× faster than the baseline Schubfach (13.12 ns).
• For float-to-string conversion, xjb is about 96% faster than zmij.
• For double-to-string conversion, xjb is about 20% faster than zmij.

4.5.2. Performance Consistency

A key advantage of the xjb algorithm is its consistent performance across different input distributions. Since all branches in the xjb implementation are designed to be unlikely branches, the algorithm maintains a high branch prediction success rate regardless of input patterns. This property is particularly valuable in real-world applications where input distributions may vary unpredictably.

4.5.3. Cross-Platform Performance

The benchmark results demonstrate that xjb performs well across different processor architectures:

• On x86-64 (AMD R7-7840H), xjb benefits from the compiler’s ability to generate efficient code for the algorithm’s arithmetic operations.
• On ARM64 (Apple M1), xjb maintains its performance advantage, demonstrating the algorithm’s portability and effectiveness across different instruction set architectures.

4.5.4. Comparison with Related Algorithms

• vs. Schubfach: xjb achieves 3–5× speedup over the baseline Schubfach algorithm, validating the effectiveness of our optimizations in reducing multiplication operations and minimizing branch prediction penalties.
• vs. yy_json/yy_double: While these algorithms are highly optimized for JSON serialization workloads, xjb outperforms them by 1.3–1.8×, demonstrating broader applicability beyond specific use cases.
• vs. zmij: xjb achieves 1.5–1.9× speedup over zmij, another recent high-performance algorithm, showing the benefits of our approach to instruction dependency reduction.
• vs. Ryu and Dragonbox: xjb significantly outperforms these widely-used algorithms (2.5–6× faster), demonstrating that the optimizations in xjb provide substantial benefits over established approaches.

4.6. Summary

The experimental evaluation demonstrates that xjb achieves state-of-the-art performance for floating-point to decimal conversion across multiple hardware platforms. The algorithm’s key strengths include:

1.

Consistently superior performance across both x86-64 and ARM64 architectures.

2.

Significant speedups over the baseline Schubfach algorithm (3–5×).

3.

Competitive or superior performance compared to all other state-of-the-art algorithms.

4.

Stable performance regardless of input distribution due to effective branch prediction optimization.

These results validate the effectiveness of our optimization strategies: reducing multiplication operations, minimizing instruction dependencies, and designing branch patterns that work well with modern processor pipelines.

5. Conclusions

This paper presented xjb, a novel high-performance algorithm for converting IEEE 754 floating-point numbers to decimal string representations. Building upon the Schubfach algorithm, xjb introduces several key optimizations that significantly improve conversion speed while maintaining full compliance with the Steele-White principle for accurate and minimal-length output.

5.1. Summary of Contributions

The main contributions of this work are:

1.

Reduced computational complexity: By restructuring the calculation process and minimizing the number of high-precision multiplication operations, xjb achieves substantial performance improvements over the baseline Schubfach algorithm.

2.

Optimized branch structure: The algorithm employs unlikely branch patterns that enable efficient branch prediction on modern processors, resulting in consistent performance across diverse input distributions.

3.

Cross-platform portability: xjb demonstrates excellent performance across both x86-64 and ARM64 architectures, making it suitable for deployment in heterogeneous computing environments.

4.

Comprehensive validation: The algorithm has been thoroughly tested and verified to produce correct output for all IEEE 754 binary32 and binary64 floating-point values.

5.2. Experimental Findings

Our experimental evaluation on AMD R7-7840H and Apple M1 processors demonstrates that xjb achieves state-of-the-art performance:

• 3–5× speedup over the baseline Schubfach algorithm
• Faster than other high-performance algorithms such as yy_json, yy_double, and zmij
• Consistent performance across different input patterns and hardware platforms

5.3. Practical Implications

The xjb algorithm has immediate practical applications in numerous domains:

• Data serialization: JSON and other text-based data formats require efficient floating-point to string conversion for serialization operations.
• Scientific computing: Applications that output numerical results in human-readable format benefit from faster conversion without sacrificing accuracy.
• Database systems: Export operations and query result formatting can leverage xjb for improved throughput.
• Web services: RESTful APIs and web applications that return numerical data can achieve lower latency with efficient conversion.

5.4. Limitations and Future Work

While xjb demonstrates strong performance, several areas warrant further investigation:

1.

Extended precision support: Future work could extend xjb to support extended precision formats (e.g., 80-bit and 128-bit floating-point numbers) for applications requiring higher precision.

2.

SIMD vectorization: Although xjb is designed to be SIMD-friendly, explicit vectorization using AVX-512 or NEON could yield additional performance gains for batch conversion workloads.

3.

Compiler compatibility: Further optimization for different compilers (particularly MSVC) would improve portability across development environments.

4.

Memory-constrained environments: Investigating memory-efficient variants of xjb could benefit embedded systems and other resource-constrained platforms.

5.5. Availability

The complete implementation of the xjb algorithm, along with benchmark tools and test suites, is publicly available at https://github.com/xjb714/xjb/releases/tag/v1.0.0. We encourage the community to integrate, test, and contribute to the ongoing development of this work.