uint r = 1;
本文的方针是在Solidity中实现以下成果：
uint xlyl = xl * yl; uint xlyh = xl * yh;
return l * r;
return
由于两个256位无标记整数的乘积不能高出512位，因此较宽的范例必需至少为512位宽。我们可以通过两个256位无标记整数对别离模仿512位无标记整数，这两个整数别离持有整个512位数字的低256位和高256位。
uint hh = (xhyh >> 128);
{
在Solidity中利用浮点数
function mulDiv (uint x, uint y, uint z)
r *= 2 – z * r;
function mulDiv (uint x, uint y, uint z)
else e >>= (zShift – lShift);
l += h * ((-pow2) / pow2 + 1);
上面的公式是求解比例的非凡环境。凡是比例是以下形式的方程：a÷b = c÷d，要求解比例，就是要找到一个知道其他三个值的值。譬喻可以从a，b和c中找到d，如下所示：d = b×c÷a。
if (mm < l) h -= 1;
r *= 2 – z * r;
require (h < z);
uint mm = mulmod (x, y, z);
return fullDiv (l, h, z);
在这里，我们利用普通的+和*运算符以提高可读性，而真实代码应利用SafeMath函数来防备真实（即非幻像）溢出。
该代码担保了正确的功效，所以此刻所有的要求好像都满意了，对吧？没那么快。
uint shiftedZ = z;
l -= tl;
l = ll + (lh << 128);
public pure returns (uint)
{
结论
}
z /= pow2;
return x * y / z;
if (x >= 2**8) { x >>= 8; r += 8; }
h -= th;
{
uint ll = uint128 (xlyl);
}
if (x >= 2**64) { x >>= 64; r += 64; }
由于无法还原幻像溢出，因此
if (mm > l) h -= 1;
r *= 2 – z * r;
l -= mm;
function mulDiv (uint x, uint y, uint z)
uint yl = uint128 (y); uint yh = y >> 128;
r *= 2 – z * r;
public pure returns (uint)
(a×z+b)×(c×z+d)÷z=
function mulDiv (uint x, uint y, uint z)
}
x×y÷z=
)
}
因此，该函数可以这样重写：
if (lShift > zShift) e <<= (lShift – zShift);
if (x >= 2**32) { x >>= 32; r += 32; }
防备Solidity中乘法溢出的常用要领是利用SafeMath库中的mul函数：
}
if (x >= 2**1) { x >>= 1; r += 1; }
function fullDiv (uint l, uint h, uint z)
l /= pow2;
}
}
else
require (x > 0);
),
return a * b * z + a * d + b * c + b * d / z;
uint hShift = 256 – lShift;
uint e = ((h << hShift) + (l >> lShift)) / shiftedZ;
h = mm – l;
此办理方案根基上满意大大都要求：好像计较x×y÷z，将功效四舍五入，并在z为零的环境下抛出。可是，存在一个问题：它实际计较的是x×y mod2²⁵⁶÷z。这就是Solidity中乘法溢出的事情方法。当乘法功效不适合256位时，仅返回功效的最低256位。对付x和y较小的值，当x×y <2²⁵⁶时，没有差别，可是对付较大的x和y，这将发生错误的功效。所以第一个问题是：
金融数学始于百分比。y的x百分比是几多？x的几多百分比是y？我们都知道谜底：y的x百分比是x×y÷100，y是y×100÷x百分比。这是学校学的数学。
public pure returns (uint)
幻像溢出问题的来源在于中间乘法功效不适合256位。因此，让我们利用更遍及的范例。Solidity自己不支持大于256位的数字范例，因此我们将不得不模仿它们。我们根基上需要两个操纵：uint×uint→wide和wide÷uint→uint。
迈向全比例
shiftedZ = (shiftedZ – 1 >> zShift) + 1;
l = x * y;
在Javascript中，可以这样简朴地计较x×y÷z：x * y / z。靠得住地，这样的表达式不会通过安详审核，因为对付足够大的x和y乘法大概会溢出，因此计较功效大概不正确。利用SafeMath并没有多大辅佐，因为纵然最终计较功效适合256位，它也会使事务失败。在上一篇文章中，我们称这种环境为“幻像溢出”。在像x / z * y或y / z * x之类的乘法之前举办除法可以办理幻像溢出问题，但大概导致精度低落。
首先，我们重写fullMul函数：
{
);
我们可以自制吗？
根基先容
function mulDiv (uint x, uint y, uint z)
ABDKMathQuad.mul (
{
r *= 2 – z * r;
}
ABDKMathQuad.toUInt (
ABDKMathQuad.fromUInt (y)
让我们以学校数学的方法实现这两个函数：
function mulDiv (uint x, uint y, uint z)
和
在此实现中，幻像溢出仍然是大概的，但仅在最后一项中：b*d/z。可是由于b和d都小于z，因此担保了该代码在z≤212时能正常事情，因此可以担保b×d适合256位。因此可以在已知z不高出2^128的环境下利用此实现。一个常见的例子是18位小数的定点乘法：x×y÷10¹⁸。
ABDKMathQuad.fromUInt (x),
实际上我们可以。固然焦点语言不支持浮点，但有些库支持。譬喻利用ABDKMathQuad库，可以编写：
uint xl = uint128 (x); uint xh = x >> 128;
{
return mul (x, y) / z;
这里的mostSignificantBit是一个函数，它返回参数最高有效位的从零开始的索引。此成果可以通过以下方法实现：
function fullMul (uint x, uint y)
这里fullMul函数将两个256位无标记整数相乘，并将功效作为512位无标记整数分成两个256位部门返回。函数fullDiv将512位无标记整数相除，以两个256位无标记整数形式通报，但以256位无标记整数形式通报，并以256位无标记整数形式返回功效。
r += l / z;
zShift -= 127;
uint zShift = mostSignificantBit (z);
public pure returns (uint l, uint h)
r += e;
{
这个实现每次mulDiv挪用只耗损约莫550 gas，而且可以进一步优化。比学校数学要领好5倍。很好！可是，实际上必需得到数学博士学位才气编写这样的代码，而且并非每个问题都具有这样的数学办理方案。假如可以的话，工作会简朴得多。
uint hl = uint128 (xhyh) + (xlyh >> 128) + (xhyl >> 128);
require (h < z);
不像JavaScript那样优雅，不像mathemagic办理方案那样自制（甚至比学校的数学要领更具扩展性），但长短常简朴和准确，因为这里利用的四倍精度浮点数有约莫33个有效小数。
uint pow2 = z & -z;
这将计较x×y÷z，将功效四舍五入，并在z为零的功效不适合uint的环境下抛出。让我们从以下简朴的办理方案开始：
正如在上一篇文章中所展示的那样，在主流编程语言中简朴明白，在Solidity中，如此简朴的计较令人惊奇地具有挑战性。这有两个原因：i）实体不支持分数；ii）Solidity中的数字范例大概会溢出。
让我们举办以下替换：x = a×z + b和y = c×z + d，个中a，b，c和d是整数，0≤b<z和0≤d<z。然后：
因此，代码大概如下所示：
以下代码基于Remco Bloemen描写的令人欢快的数学发明。
h = (lh >> 128) + hl + (hh << 128);
function mulDiv (uint x, uint y, uint z)
public pure returns (uint r) {
我们如何防备溢出？
if (tl > l) h -= 1;
我们如何制止幻像溢出保持精度？
if (x >= 2**2) { x >>= 2; r += 2; }
uint xhyl = xh * yl; uint xhyh = xh * yh;
ABDKMathQuad.div (
while (h > 0)
uint a = x / z; uint b = x % z; // x = a * z + b
(uint tl, uint th) = fullMul (e, z);
在本文中，我们发明Solidity中有哪些更好的要领来处理惩罚百分比和比例。
if (x >= 2**16) { x >>= 16; r += 16; }
上面的代码相当巨大，大概需要表明，但我们此刻将跳过表明，而将重点放在差异的问题上。这段代码的问题是，每次挪用mulDiv函数约莫要耗损2.5K gas，这是相当多的。所以，
每一次fullMul挪用可以节减约莫250gas。
(uint l, uint h) = fullMul (x, y);
}
public pure returns (uint) {
通过别离将x和y除以z，可以将值a，，b，c和d计较为商和余数。
要求是在功效不适合uint的环境下还原，而且此实现好像可以满意要求。可是纵然最终功效符合，当x×y不适合uint时，此实现也会还原。我们称这种环境为“幻像溢出”。在上一篇文章中，我们展示了如何故准确度为价钱办理幻像溢出，可是该办理方案在这里不起浸染，因为我们需要准确的准确功效。
}
if (zShift <= 127) zShift = 0;
public pure returns (uint)
uint lShift = mostSignificantBit (h) + 1;
uint mm = mulmod (x, y, uint (-1));
if (x >= 2**128) { x >>= 128; r += 128; }
public pure returns (uint)
public pure returns (uint) {
正如我们在本文开头所说的，在JavaScript中，只需编写一个*b/c，其余部门由语言来处理惩罚。假如我们能在Solidity上做同样的事呢？
(uint l, uint h) = fullMul (x, y);
uint lh = (xlyl >> 128) + uint128 (xlyh) + uint128 (xhyl);
function mostSignificantBit (uint x) public pure returns (uint r) {
public pure returns (uint l, uint h)
我们如何才气完全制止幻影溢出？
uint c = y / z; uint d = y % z; // y = c * z + d
r *= 2 – z * r;
a×b×z+a×d+b×c+b×d÷z
(a×b×z²+(a×d+b×c)×z+b×d)÷z=
ABDKMathQuad.fromUInt (z)
}
}
r *= 2 – z * r;
{
r *= 2 – z * r;
if (x >= 2**4) { x >>= 4; r += 4; }
此实现方法耗损的气体有一半以上用于将uint值转换为浮点数和浮点数，比例计较自己仅耗损约1.4K gas。因此在所有智能合约中利用浮点数大概比殽杂整数和浮点数自制得多。
function fullMul (uint x, uint y)
由于溢出和缺少分数支持，因此百分比和比例在Solidity中大概具有挑战性。可是，各类数学能力都可以正确有效地办理比例问题。
郑重声明：本文版权归原作者所有，转载文章仅为传播更多信息之目的，如作者信息标记有误，请第一时间联系我们修改或删除，多谢。
