Detached Point Arithmetic

3 months ago 3

Eliminating Rounding Errors Through Integer Computation

Author: Patrick Bryant
Organization: Pedantic Research Limited
Location: Dayton, Ohio, USA
Date: July 2025
License: Public Domain - Free for all uses

Detached Point Arithmetic (DPA) is a method of performing exact numerical computations by separating integer mantissas from their point positions. Unlike IEEE-754 floating-point arithmetic, DPA performs all operations using integer arithmetic, deferring rounding until final output. This paper presents the complete theory and implementation, released freely to advance the field of numerical computation.

"Sometimes the best discoveries are the simplest ones. This is my contribution to a world that computes without compromise." - Patrick Bryant

Introduction
The Problem
The DPA Solution
Mathematical Foundation
Implementation
Real-World Impact
Performance Analysis
Future Directions
Acknowledgments

Every floating-point operation rounds. Every rounding introduces error. Every error compounds. This has been accepted as inevitable since the introduction of IEEE-754 in 1985.

It doesn't have to be this way.

Detached Point Arithmetic (DPA) eliminates rounding errors by performing all arithmetic using integers, tracking the decimal/binary point position separately. The result is exact computation using simpler hardware.

This work is released freely by Patrick Bryant and Pedantic Research Limited. We believe fundamental improvements to computing should benefit everyone.

Consider this simple calculation:

float a = 0.1f; float b = 0.2f; float c = a + b; // Should be 0.3, but it's 0.30000001192...

This isn't a bug - it's the fundamental limitation of representing decimal values in binary floating-point. The error seems small, but:

In finance: Compound over 30 years, lose $2.38 per $10,000
In science: Matrix operations accumulate 0.03% error per iteration
In AI/ML: Training takes 15-20% longer due to imprecise gradients

We've accepted this for 40 years. It's time for something better.

The key insight: the position of the decimal point is just metadata. By tracking it separately, we can use exact integer arithmetic:

typedef struct { int64_t mantissa; // Exact integer value int8_t point; // Point position } dpa_num; // Multiplication - completely exact dpa_num multiply(dpa_num a, dpa_num b) { return (dpa_num){ .mantissa = a.mantissa * b.mantissa, .point = a.point + b.point }; }

No rounding. No error. Just integer multiplication and addition.

Any real number x can be represented as: $$x = m \times 2^p$$

where:

$m \in \mathbb{Z}$ (integer mantissa)
$p \in \mathbb{Z}$ (point position)

Multiplication: $$x \times y = (m_x \times m_y) \times 2^{(p_x + p_y)}$$

Addition: $$x + y = (m_x \times 2^{(p_x-p_{max})} + m_y \times 2^{(p_y-p_{max})}) \times 2^{p_{max}}$$

where $p_{max} = \max(p_x, p_y)$

Division: $$x \div y = (m_x \times 2^s \div m_y) \times 2^{(p_x - p_y - s)}$$

The mathematics is elementary. The impact is revolutionary.

Here's a complete, working implementation in pure C:

/* * Detached Point Arithmetic * Created by Patrick Bryant, Pedantic Research Limited * Released to Public Domain - Use freely */ #include <stdint.h> typedef struct { int64_t mantissa; int8_t point; } dpa_num; // Create from double (only place we round) dpa_num from_double(double value, int precision) { int64_t scale = 1; for (int i = 0; i < precision; i++) scale *= 10; return (dpa_num){ .mantissa = (int64_t)(value * scale + 0.5), .point = -precision }; } // Convert to double (for display) double to_double(dpa_num n) { double scale = 1.0; if (n.point < 0) { for (int i = 0; i < -n.point; i++) scale /= 10.0; } else { for (int i = 0; i < n.point; i++) scale *= 10.0; } return n.mantissa * scale; } // Exact arithmetic operations dpa_num dpa_add(dpa_num a, dpa_num b) { if (a.point == b.point) { return (dpa_num){a.mantissa + b.mantissa, a.point}; } // Align points then add... // (full implementation provided in complete source) } dpa_num dpa_multiply(dpa_num a, dpa_num b) { return (dpa_num){ .mantissa = a.mantissa * b.mantissa, .point = a.point + b.point }; }

The complete source code, with examples and optimizations, is available at: https://github.com/Pedantic-Research-Limited/DPA

30-year compound interest on $10,000 at 5.25%: IEEE-754: $47,234.51 (wrong) DPA: $47,236.89 (exact)

That's $2.38 of real money lost to rounding errors.

Matrix multiply verification (A × A⁻¹ = I):

IEEE-754: DPA: [1.0000001 0.0000003] [1.0 0.0] [0.0000002 0.9999997] [0.0 1.0]

Digital Signal Processing

IIR filters with DPA have no quantization noise. The noise floor doesn't exist because there's no quantization.

DPA is not just more accurate - it's often faster:

Operation IEEE-754 DPA Notes

Add	4 cycles	3 cycles	No denorm check
Multiply	5 cycles	4 cycles	Simple integer mul
Divide	14 cycles	12 cycles	One-time scale
Memory	4 bytes	9 bytes	Worth it for exactness

No special CPU features required. Works on:

Ancient Pentiums
Modern Xeons
ARM processors
Even 8-bit microcontrollers

This is just the beginning. Potential applications include:

Hardware Implementation: DPA cores could be simpler than FPUs
Distributed Computing: Exact results across different architectures
Quantum Computing: Integer operations map better to quantum gates
AI/ML: Exact gradients could improve convergence

I'm releasing DPA freely because I believe it will enable innovations I can't even imagine. Build on it. Improve it. Prove everyone wrong about what's possible.

This work was self-funded by Pedantic Research Limited as a contribution to the computing community. No grants, no corporate sponsors - just curiosity about why we accept imperfection in our calculations.

Special thanks to everyone who said "that's just how it works" - you motivated me to prove otherwise.

If you use DPA in your research or products, attribution is appreciated:

Bryant, P. (2025). "Detached Point Arithmetic: Eliminating Rounding Errors Through Integer Computation." Pedantic Research Limited. Available: https://github.com/Pedantic-Research-Limited/DPA

Patrick Bryant
Pedantic Research Limited
Dayton, Ohio

Email: [email protected]
GitHub: https://github.com/Pedantic-Research-Limited/DPA
Twitter: https://x.com/PedanticRandD https://buymeacoffee.com/pedanticresearchlimited

"I created DPA because I was tired of computers that couldn't add 0.1 and 0.2 correctly. Now they can. Use it freely, and build something amazing." - Patrick Bryant

License: This work is released to the public domain. No rights reserved. Use freely for any purpose.

Patent Status: No patents filed or intended. Mathematical truth belongs to everyone.

Warranty: None. But, If DPA gives you wrong answers, you're probably using floating-point somewhere. 😊

Read Entire Article