64 位数学运算，不会丢失任何数据或精度
Posted
技术标签:
【中文标题】64 位数学运算，不会丢失任何数据或精度【英文标题】：64 bit mathematical operations without any loss of data or precision 【发布时间】：2014-09-18 03:05:00 【问题描述】：我相信 128 位数据没有任何可移植的标准数据类型。所以，我的问题是如何在不丢失数据的情况下使用现有的标准数据类型高效地执行 64 位操作。
例如：我有以下两个 uint64_t 类型变量：
uint64_t x = -1; uint64_t y = -1;
现在，x+y, x-y, x*y and x/y 等数学运算的结果如何存储/检索/打印？
对于上述变量，x+y 的值是 -1，实际上是一个 0xFFFFFFFFFFFFFFFFULL，进位为 1。
void add (uint64_t a, uint64_t b, uint64_t result_high, uint64_t result_low)
result_low = result_high = 0;
result_low = a + b;
result_high += (result_low < a);
如何像add 那样执行其他操作，从而提供正确的最终输出？
如果有人分享处理溢出/下溢等问题的通用算法，我将不胜感激。
任何可能有帮助的标准测试算法。
【问题讨论】：
为什么使用 64 位数字需要 128 位数据类型？很难看出你困惑的根源。 只要没有溢出就可以了 - 但如果uint128_t 是标准的（__uint128_t 是 gcc 和 clang 的扩展），它只会推迟一般问题。
Re: “处理上溢/下溢” - 在 C 中，查看 safe_ops。我认为这就是它的名称，它被android使用。你可以在谷歌代码上找到它。在 C++ 中，请参阅 LeBlanc 的 SafeInt 类。你可以在 CodePlex 找到它。
你可以写一本关于这个主题的小书。加法几乎是微不足道的，乘法很容易用几个技巧，除法在概念上并不是那么困难，但有点苦差事。这真的只是基础数学，就像你在三年级时学到的一样。
how the result of [operations] can be stored/retrieved/printed 在 C 中，分配给参数（按值传递）不会有帮助。有一点历史的一种方法 (modf(value, integralPart)...) 是返回“主要”结果并将“其他”分配给传入的指针所指向的东西，如果不是 NULL。
【参考方案1】：
有很多 BigInteger 库可以处理大数字。
-
GMP Library
C++ Big Integer Library
如果您想避免库集成并且您的要求很小，这是我的基本BigInteger sn-p，我通常用于基本要求的问题。您可以根据需要创建新方法或重载运算符。 此 sn-p 经过广泛测试且无错误。
来源
class BigInt
public:
// default constructor
BigInt()
// ~BigInt() // avoid overloading default destructor. member-wise destruction is okay
BigInt( string b )
(*this) = b; // constructor for string
// some helpful methods
size_t size() const // returns number of digits
return a.length();
BigInt inverseSign() // changes the sign
sign *= -1;
return (*this);
BigInt normalize( int newSign ) // removes leading 0, fixes sign
for( int i = a.size() - 1; i > 0 && a[i] == '0'; i-- )
a.erase(a.begin() + i);
sign = ( a.size() == 1 && a[0] == '0' ) ? 1 : newSign;
return (*this);
// assignment operator
void operator = ( string b ) // assigns a string to BigInt
a = b[0] == '-' ? b.substr(1) : b;
reverse( a.begin(), a.end() );
this->normalize( b[0] == '-' ? -1 : 1 );
// conditional operators
bool operator < (BigInt const& b) const // less than operator
if( sign != b.sign ) return sign < b.sign;
if( a.size() != b.a.size() )
return sign == 1 ? a.size() < b.a.size() : a.size() > b.a.size();
for( int i = a.size() - 1; i >= 0; i-- ) if( a[i] != b.a[i] )
return sign == 1 ? a[i] < b.a[i] : a[i] > b.a[i];
return false;
bool operator == ( const BigInt &b ) const // operator for equality
return a == b.a && sign == b.sign;
// mathematical operators
BigInt operator + ( BigInt b ) // addition operator overloading
if( sign != b.sign ) return (*this) - b.inverseSign();
BigInt c;
for(int i = 0, carry = 0; i<a.size() || i<b.size() || carry; i++ )
carry+=(i<a.size() ? a[i]-48 : 0)+(i<b.a.size() ? b.a[i]-48 : 0);
c.a += (carry % 10 + 48);
carry /= 10;
return c.normalize(sign);
BigInt operator - ( BigInt b ) // subtraction operator overloading
if( sign != b.sign ) return (*this) + b.inverseSign();
int s = sign;
sign = b.sign = 1;
if( (*this) < b ) return ((b - (*this)).inverseSign()).normalize(-s);
BigInt c;
for( int i = 0, borrow = 0; i < a.size(); i++ )
borrow = a[i] - borrow - (i < b.size() ? b.a[i] : 48);
c.a += borrow >= 0 ? borrow + 48 : borrow + 58;
borrow = borrow >= 0 ? 0 : 1;
return c.normalize(s);
BigInt operator * ( BigInt b ) // multiplication operator overloading
BigInt c("0");
for( int i = 0, k = a[i] - 48; i < a.size(); i++, k = a[i] - 48 )
while(k--) c = c + b; // ith digit is k, so, we add k times
b.a.insert(b.a.begin(), '0'); // multiplied by 10
return c.normalize(sign * b.sign);
BigInt operator / ( BigInt b ) // division operator overloading
if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 );
BigInt c("0"), d;
for( int j = 0; j < a.size(); j++ ) d.a += "0";
int dSign = sign * b.sign;
b.sign = 1;
for( int i = a.size() - 1; i >= 0; i-- )
c.a.insert( c.a.begin(), '0');
c = c + a.substr( i, 1 );
while( !( c < b ) ) c = c - b, d.a[i]++;
return d.normalize(dSign);
BigInt operator % ( BigInt b ) // modulo operator overloading
if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 );
BigInt c("0");
b.sign = 1;
for( int i = a.size() - 1; i >= 0; i-- )
c.a.insert( c.a.begin(), '0');
c = c + a.substr( i, 1 );
while( !( c < b ) ) c = c - b;
return c.normalize(sign);
// << operator overloading
friend ostream& operator << (ostream&, BigInt const&);
private:
// representations and structures
string a; // to store the digits
int sign; // sign = -1 for negative numbers, sign = 1 otherwise
;
ostream& operator << (ostream& os, BigInt const& obj)
if( obj.sign == -1 ) os << "-";
for( int i = obj.a.size() - 1; i >= 0; i--)
os << obj.a[i];
return os;
用法
BigInt a, b, c;
a = BigInt("1233423523546745312464532");
b = BigInt("45624565434216345i657652454352");
c = a + b;
// c = a * b;
// c = b / a;
// c = b - a;
// c = b % a;
cout << c << endl;
// dynamic memory allocation
BigInt *obj = new BigInt("123");
delete obj;
【讨论】：
【参考方案2】：如果没有uint128_t，可以仿效：
typedef struct uint128_t uint64_t lo, hi uint128_t;
...
uint128_t add (uint64_t a, uint64_t b)
uint128_t r; r.lo = a + b; r.hi = + (r.lo < a); return r;
uint128_t sub (uint64_t a, uint64_t b)
uint128_t r; r.lo = a - b; r.hi = - (r.lo > a); return r;
没有内置编译器或汇编器支持的乘法有点难以正确。本质上，您需要将两个被乘数拆分为 hi:lo 无符号 32 位，并执行“长乘法”处理部分 64 位乘积之间的进位和“列”。
在给定 64 位参数的情况下，除法和取模返回 64 位结果 - 所以这不是问题，因为您已经定义了问题。将 128 位除以 64 或 128 位操作数是一个更复杂的操作，需要归一化等。
longlong.h 例程umul_ppmm 和GMP 中的udiv_qrnnd 给出了多精度/肢体操作的“基本”步骤。
【讨论】：
感谢您的回答，您能分享一个乘法运算的伪代码吗？ @HarryCruise -umul_ppmm 是您要找的。这是longlong.h末尾的“普通C”实现。【参考方案3】：
大多数现代 GCC 编译器都支持 __int128 类型，它可以容纳 128 位整数。
例子，
__int128 add(__int128 a, __int128 b)
return a + b;
【讨论】：
以上是关于64 位数学运算，不会丢失任何数据或精度的主要内容，如果未能解决你的问题，请参考以下文章