Lord of the Precision, the Two Floats: Double-Word Arithmetic for Complex Numbers

arXiv:2611.08371 · cs.MS · Submitted 2026-11-05 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Lord of the Precision, the Two Floats".

Jane: Here's the gist of the paper. Double-word (DW) arithmetic represents numbers as unevaluated sums of two floating-point values, providing higher accuracy The paper presents the first error analysis of complex DW multiplication and division, establishing relative error bounds for various variants using different addition algorithms This research is relevant to fields relying on complex arithmetic such as quantum physics and signal processing Error Analysis of Addition Algorithms The paper compares three double-word addition algorithms: Sloppy, Accurate, and Madd, in terms of performance and accuracy Algorithm 3 (Madd) has the tightest relative error bound of 2u squared The analysis shows that the less expensive sloppy addition suffices for these variants.

Tom: Specifically, Algorithm 3 satisfies up to leading order the absolute error bound Z − S ≤ 2u squared + O(u 3) X + Y Error Analysis of Multiplication and Division The authors investigate the robustness of double-word addition algorithms when the input components overlap, proving that Madd remains accurate and more robust than alternative addition algorithms They establish error bounds for complex multiplication and division across all combinations of the double-word addition and multiplication algorithms considered For complex division, the relative error bound is given by Rb − R R ≤ εdiv(1 + εN) + εN + εD ≈ εdiv + εN + εD Performance and Implementation The authors develop the open-source CompleXDW library for complex double-word arithmetic targeting CPUs, including SIMD implementations, and GPUs through CUDA and HIP In a high-energy physics application on GPUs, the library achieves nearly three times the throughput of native FP64 arithmetic Performance experiments show that omitting normalization in the multiplications produces overlapping inputs to the addition, with an overlap parameter of approximately 3 The paper demonstrates that both renormalizations performed by FastTwoSum in Algorithm 3 (Madd) remain error-free under round-to-nearest rounding, under a mild assumption on the input overlap The experimental results are consistent with the theoretical error bounds On GPUs with reduced FP64 throughput, replacing FP64 arithmetic with FP32-based double-word arithmetic in the matrix-element computations of MadGraph7 increases the event processing rate The speedup reaches 2.9× on the NVIDIA L40S and 2.1× on the AMD Radeon Pro W7900 Appendix Details The appendix provides details for generating inputs with a prescribed condition number, including Algorithm 9 The worst-case search explores inputs to maximize the score n = max c ∈ c ∈ re, im Rbc − Rc Rc κc u squared, where Rc is a component of the exact result The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far Related Work The paper reviews related work in complex floating-point arithmetic, including error-free transformations for complex numbers and pair arithmetic without normalization It discusses the use of fused operators for achieving lower relative errors in double-word algorithms The work also touches upon quasi double- and triple-word algorithms used in conjugate gradient solvers Acknowledgement The work done by Frantiˇsek Stloukal was supported by the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project (grant agreement SIF- 2023-004) The work of Fabienne J´ez´equel was supported by the NumPEx ExaMA (ANR-22-EXNU-0002) and the FPT-4 (ANR-24-CE46-7572) projects of the French National Agency for Research (ANR) The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication The scientific content, methodology, results, and interpretations remain solely the authors’ work References The paper cites numerous references including

5: for complex floating-point multiplication error bounds and

24: for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors take full responsibility for the content of this publication The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work Appendix A Generation of inputs with a prescribed condition number The algorithm presented here follows the usual complex number multiplication structure where we take the imaginary component of the result as our candidate for the computation of the condition number The input generation process involves drawing random numbers and then choosing a fourth input to attain a prescribed κ The algorithm follows specific cases based on the signs of q and p + q to determine the required value for b The search looks for inputs A + iB and C + iD for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far The candidate is rejected if a word is zero or not finite, if a low word lies more than 200 − p binades below its high word, so that MPFR stays exact Each operand is then scaled by a power of two so that its largest word has exponent 0 The relative errors do not depend on this scaling in the absence of underflow The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work Appendix B Worst-case search The worst-case search looks for inputs A + iB and C + iD, with double-word components A, B, C, D, for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared Any way of constructing valid double-word inputs can be used and the only goal of the algorithm is to find larger errors than random sampling does in the same number of trials The search runs on several threads, and its state is checkpointed periodically References The paper cites numerous references including

5: for complex floating-point multiplication error bounds and

24: for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work Acknowledgement The work done by Frantiˇsek Stloukal was supported by the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project (grant agreement SIF- 2023-004) The work of Fabienne J´ez´equel was supported by the NumPEx ExaMA (ANR-22-EXNU-0002) and the FPT-4 (ANR-24-CE46-7572) projects of the French National Agency for Research (ANR) The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work Appendix A Generation of inputs with a prescribed condition number The algorithm presented here follows the usual complex number multiplication structure where we take the imaginary component of the result as our candidate for the computation of the condition number The input generation process involves drawing random numbers and then choosing a fourth input to attain a prescribed κ The algorithm follows specific cases based on the signs of q and p + q to determine the required value for b The search looks for inputs A + iB and C + iD for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far The candidate is rejected if a word is zero or not finite, if a low word lies more than 200 − p binades below its high word, so that MPFR stays exact Each operand is then scaled by a power of two so that its largest word has exponent 0 The relative errors do not depend on this scaling in the absence of underflow References The paper cites numerous references including

5: for complex floating-point multiplication error bounds and

24: for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1

cs.MS: 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.

Title and authors: Tom: So we’re looking at a paper called Lord of the Precision, the Two Floats: Double-Word Arithmetic for Complex Numbers today. It sounds like they’re tackling a real problem in high-energy physics where you need high precision but you want to run faster on GPUs.

Jane: That’s right, and this paper is looking at how to represent numbers as sums of two floating point values to get better accuracy without the massive cost of full double precision everywhere. It introduces this double word arithmetic approach as a way to handle complex numbers more efficiently.

The paper's summary: Tom: So this paper summarizes their findings on how these different double word addition algorithms perform when you multiply and divide complex numbers using this new representation. It focuses heavily on the error bounds they found for those specific operations.

Jane: They are comparing three addition algorithms, Sloppy, Accurate, and Madd to see which one gives them the tightest relative error bound when the inputs overlap. It seems like Madd is actually the best performer in terms of accuracy for those complex operations.

Lu: The paper shows that while they can use a less expensive sloppy addition algorithm and still stay accurate up to a certain order, Algorithm three which is Madd, gives them the tightest bound of two u squared when dealing with overlapping inputs <ref:2611.08371#pg1>.

Meng: So the implication here is that if you’re doing simulations where the inputs are coming from previous steps, like in high energy physics, using that specific addition method might be crucial for maintaining accuracy across those steps.

Lalam: It also explores how robust these addition algorithms are when the input components actually overlap during complex multiplication and division, proving that Madd is more accurate and more robust than some of the other options they tested.

The paper's improvements: Tom: The authors suggest a few specific improvements to make this system even better. They look at how they can use Algorithm three which is Madd, for addition to achieve that tight relative error bound of two u squared when inputs overlap <ref:2611.08371#pg1>.

Jane: That sounds like they’re focusing on using the best addition method available for the most sensitive operations, which is a smart move for keeping things precise where it matters most.

Lu: They also look at omitting the final normalization step in double word multiplication and squaring and they bound that resulting overlap by three u plus O of u squared. This is interesting because omitting that step actually reduces the number of arithmetic operations significantly.

Meng: Reducing operation counts is always good for runtime, especially when you are running things on GPUs where FP64 throughput might be lower than you’d hope. They found this omission cuts operations by about twenty-two percent for Algorithm one and about seventeen percent for Algorithms two and three <ref:2611.08371#pg1>.

Lalam: And they suggest using the less expensive Sloppy double word plus double word addition when dealing with complex multiplication or division where the contribution of product errors already grows with kappa, which keeps the computational cost low by only requiring eleven floating point operations for addition.

Conclusion: Tom: So to wrap up, this paper shows that even when you omit normalization in those multiplications and squaring steps, if you have a mild assumption about the input overlap, the results from using Algorithm three remain error free under round to nearest rounding <ref:2611.08371#pg1>.

Jane: They confirm that their experimental results line up with their theoretical error bounds, showing they are consistent across all the variants they tested for complex multiplication and division.

Lu: The key finding is that for complex division, the relative error bound is expressed by alpha kappa plus beta u squared plus O of u cubed, where kappa is the condition number of the sum of products.

Meng: It’s interesting that they also showed how replacing FP64 arithmetic with FP32 based double word arithmetic in matrix element computations for MadGraph7 increases the event processing rate on GPUs by nearly three times.

Lalam: They also confirmed that using this lower precision method speeds up event processing, reaching a speedup of two point nine times on the NVIDIA L40S and two point one times on the AMD Radeon Pro W7900.

Tom: So what this means is that for those running high energy physics simulations, swapping out some of the standard FP64 math for this double word arithmetic can give you a significant boost in processing speed, especially on modern GPUs.

Jane: It shows that you can maintain a good level of accuracy in complex calculations while still getting much better performance than traditional methods allow.

Lu: The work with CompleXDW library is also presented as an open source tool that targets CPUs and GPUs through CUDA and HIP, which makes this whole approach accessible for deployment.

Meng: It’s important that they found ways to make this usable on hardware, not just in a theoretical notebook, because running things at scale is where the real test is.

Lalam: The Lord of the Precision, the Two Floats: Double Word Arithmetic for Complex Numbers paper provides a solid framework for how we can handle complex math with higher throughput and better error control in demanding scientific applications.

CERN · Sorbonne University · Université Paris-Panthພon-Assas

cs.MS

Submitted: 2026-11-05

Updated: 2026-11-05

Comments: 46 pages, 8 figures, 3 tables

Code: https://github.com/stloufra/CompleXDW

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: Double-word (DW) arithmetic represents numbers as unevaluated sums of two floating-point values, providing higher accuracy The paper presents the first error analysis of complex DW multiplication and…

Key concepts

Double-Word (DW) Arithmetic
This system represents numbers as sums of two floating-point values instead of a single standard float. This technique aims to increase numerical accuracy by using more precision in calculations, which is crucial for complex arithmetic where errors can accumulate quickly. It provides higher accuracy than standard single-word methods.
Error Analysis Bounds
These are mathematical limits that define the maximum possible error when performing complex multiplication and division using double-word arithmetic. The paper establishes specific bounds, such as $|R_b - R| |R| ≈ εdiv + εN + εD, which tells researchers exactly how much precision to expect in their results.
Complex Multiplication Robustness
The study investigates how well different double-word addition algorithms handle overlapping input components during complex multiplication. It proves that the Madd algorithm provides a tighter error bound of $2u^2$ and is more robust than other methods, ensuring accuracy even when inputs share common parts.

Terminology

Summary

Double-word (DW) arithmetic represents numbers as unevaluated sums of two floating-point values, providing higher accuracy The paper presents the first error analysis of complex DW multiplication and division, establishing relative error bounds for various variants using different addition algorithms This research is relevant to fields relying on complex arithmetic such as quantum physics and signal processing

Error Analysis of Addition Algorithms

The paper compares three double-word addition algorithms: Sloppy, Accurate, and Madd, in terms of performance and accuracy Algorithm 3 (Madd) has the tightest relative error bound of 2u squared The analysis shows that the less expensive sloppy addition suffices for these variants. Specifically, Algorithm 3 satisfies up to leading order the absolute error bound Z − S ≤ 2u squared + O(u 3) X + Y

Error Analysis of Multiplication and Division

The authors investigate the robustness of double-word addition algorithms when the input components overlap, proving that Madd remains accurate and more robust than alternative addition algorithms They establish error bounds for complex multiplication and division across all combinations of the double-word addition and multiplication algorithms considered For complex division, the relative error bound is given by Rb − R R ≤ εdiv(1 + εN) + εN + εD ≈ εdiv + εN + εD

Performance and Implementation

The authors develop the open-source CompleXDW library for complex double-word arithmetic targeting CPUs, including SIMD implementations, and GPUs through CUDA and HIP In a high-energy physics application on GPUs, the library achieves nearly three times the throughput of native FP64 arithmetic Performance experiments show that omitting normalization in the multiplications produces overlapping inputs to the addition, with an overlap parameter of approximately 3

Conclusion and Findings

The paper demonstrates that both renormalizations performed by FastTwoSum in Algorithm 3 (Madd) remain error-free under round-to-nearest rounding, under a mild assumption on the input overlap The experimental results are consistent with the theoretical error bounds On GPUs with reduced FP64 throughput, replacing FP64 arithmetic with FP32-based double-word arithmetic in the matrix-element computations of MadGraph7 increases the event processing rate The speedup reaches 2.9× on the NVIDIA L40S and 2. p. 0

Where the paper says it

In the high-energy physics code MadGraph7, FP32-based DW arithmetic achieves up to 2. 1× higher throughput than FP64 on NVIDIA L40S and AMD Radeon Pro W7900 GPUs, respectively, while losing approximately 1.

1× on the AMD Radeon Pro W7900

Appendix Details

The appendix provides details for generating inputs with a prescribed condition number, including Algorithm 9 The worst-case search explores inputs to maximize the score n = max c ∈ c ∈ re, im Rbc − Rc Rc κc u squared, where Rc is a component of the exact result The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far

Related Work

The paper reviews related work in complex floating-point arithmetic, including error-free transformations for complex numbers and pair arithmetic without normalization It discusses the use of fused operators for achieving lower relative errors in double-word algorithms The work also touches upon quasi double- and triple-word algorithms used in conjugate gradient solvers

Acknowledgement

The work done by Frantiˇsek Stloukal was supported by the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project (grant agreement SIF- 2023-004) The work of Fabienne J´ez´equel was supported by the NumPEx ExaMA (ANR-22-EXNU-0002) and the FPT-4 (ANR-24-CE46-7572) projects of the French National Agency for Research (ANR) The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication The scientific content, methodology, results, and interpretations remain solely the authors’ work

References

The paper cites numerous references including [5] for complex floating-point multiplication error bounds and [24] for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1 [cs. p. 0

Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

p. 0
Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

p. 0
Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

p. 0
Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

p. 0
Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

p. 0
Where the paper says it

fr 1 arXiv:2611. 08371v1 [cs.

MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5. p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

p. 0
Where the paper says it

08371v1 [cs. MS] 5 Nov 2026

5 (Anthropic) was used to assist with parts of the software implementation The authors take full responsibility for the content of this publication The paper is available on arXiv as 2611.08371v1 [cs.MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work

Appendix A Generation of inputs with a prescribed condition number

The algorithm presented here follows the usual complex number multiplication structure where we take the imaginary component of the result as our candidate for the computation of the condition number The input generation process involves drawing random numbers and then choosing a fourth input to attain a prescribed κ The algorithm follows specific cases based on the signs of q and p + q to determine the required value for b The search looks for inputs A + iB and C + iD for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far The candidate is rejected if a word is zero or not finite, if a low word lies more than 200 − p binades below its high word, so that MPFR stays exact Each operand is then scaled by a power of two so that its largest word has exponent 0 The relative errors do not depend on this scaling in the absence of underflow The paper is available on arXiv as 2611.08371v1 [cs.MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work

Appendix B Worst-case search

The worst-case search looks for inputs A + iB and C + iD, with double-word components A, B, C, D, for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared Any way of constructing valid double-word inputs can be used and the only goal of the algorithm is to find larger errors than random sampling does in the same number of trials The search runs on several threads, and its state is checkpointed periodically

The paper cites numerous references including [5] for complex floating-point multiplication error bounds and [24] for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1 [cs.MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work

The work done by Frantiˇsek Stloukal was supported by the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project (grant agreement SIF- 2023-004) The work of Fabienne J´ez´equel was supported by the NumPEx ExaMA (ANR-22-EXNU-0002) and the FPT-4 (ANR-24-CE46-7572) projects of the French National Agency for Research (ANR) The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work The paper is available on arXiv as 2611.08371v1 [cs.MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.5 (Anthropic) was used to assist with parts of the software implementation The authors reviewed and verified all AI-assisted output and take full responsibility for the content of this publication All scientific content, methodology, results, and interpretations remain solely the authors’ work

The algorithm presented here follows the usual complex number multiplication structure where we take the imaginary component of the result as our candidate for the computation of the condition number The input generation process involves drawing random numbers and then choosing a fourth input to attain a prescribed κ The algorithm follows specific cases based on the signs of q and p + q to determine the required value for b The search looks for inputs A + iB and C + iD for which double-word complex multiplication or division maximizes the score n = max c ∈ re, im Rbc − Rc Rc κc u squared The worst cases found are recomputed with 4096 bits The search combines random sampling, inputs placed at the rounding boundaries of the error-free transformations, and hill climbing from the worst inputs found so far The candidate is rejected if a word is zero or not finite, if a low word lies more than 200 − p binades below its high word, so that MPFR stays exact Each operand is then scaled by a power of two so that its largest word has exponent 0 The relative errors do not depend on this scaling in the absence of underflow

The paper cites numerous references including [5] for complex floating-point multiplication error bounds and [24] for formalization of double-word arithmetic The work also references papers on Monte Carlo event generation and various floating-point standards The authors acknowledge support from several grants related to high-energy physics computing The paper is available on arXiv as 2611.08371v1 [cs.MS] 5 Nov 2026 The authors used Perplexity (Perplexity AI) and ChatGPT (OpenAI) for language editing of this manuscript Claude Opus 5.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Implement complex multiplication using Algorithm 3 (Madd) for addition to achieve a relative error bound of 2u squared, which is tighter than Algorithms 1 and 2 when inputs overlap. This will improve accuracy in high-energy physics simulations where inputs are often outputs of previous computations.

  2. Omit the final normalization call in double-word multiplication and squaring while bounding the resulting overlap by three u plus O(u squared). This reduces floating-point operation counts by approximately 22% for Algorithm 1, 17% for Algorithms 2 and 3, and improves performance on GPUs where FP64 throughput is reduced.

  3. Utilize the less expensive SloppyDWPlusDW addition algorithm when dealing with complex multiplication or division where the contribution of product errors already grows with kappa. This choice maintains accuracy while minimizing computational cost by requiring only 11 floating-point operations for addition.

  4. Develop a library like CompleXDW that supports both CPU and GPU execution via CUDA and HIP, enabling high-energy physics simulations to achieve up to 2.9 times higher throughput than native FP64 arithmetic on NVIDIA L40S GPUs.

  5. Integrate the error analysis framework into the AI system so it can derive relative error bounds of the form (alpha kappa plus beta) u squared for complex multiplication and division across all combinations of double-word addition and multiplication algorithms.

Abstract

Datacenter GPUs increasingly favour low-precision floating-point formats, offering higher throughput than FP64. Double-word (DW) arithmetic represents numbers as unevaluated sums of two floating-point values, providing higher accuracy. We present the first error analysis of complex DW multiplication and division. Both operations reduce to sums of two DW products, combined using one of three DW addition algorithms: accurate, sloppy, or Madd. Normalising DW products ensures nonoverlapping components, but omitting this step reduces the number of arithmetic operations. We bound the resulting overlap and prove that Madd retains a relative error bound of 3u 2+O(u 3) for overlapping inputs, where u is the unit roundoff. For all variants, we establish relative error bounds of the form (ακ+β)u 2+O(u 3), where κ is the condition number of the sum of products. Our analysis shows that the less expensive sloppy addition suffices. We implement these variants in CompleXDW, an open-source C++ library for CPUs and GPUs. In the high-energy physics code MadGraph7, FP32-based DW arithmetic achieves up to 2.9x and 2.1x higher throughput than FP64 on NVIDIA L40S and AMD Radeon Pro W7900 GPUs, respectively, while losing approximately 1.4 correct significant digits.

Sources

Related papers