128.128坚固的未签名固定点划分

Question

我目前正在尝试找出一种在两个128.128 UINT256数字上执行固定点分裂的具体方法。这似乎是一件相当简单的事情，但无法将解决方案编码。

对于两个64.64固定点编号，以下功能正常。

function div64x64 (uint128 x, uint128 y) internal pure returns (uint128) {
    unchecked {
        require (y != 0);
    
        uint256 answer = (uint256 (x) << 64) / y;

        require (answer <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return uint128 (answer);
    }
}

但是UINT256 128.128固定点编号不能保持相同的逻辑，因为您不能将X施加到较大的UINT类型中，左移X。这是我为128.128解决此问题的可悲尝试，该尝试不包括输出中的正确小数，但我的尝试确实包括小数的正确值。

function div128x128 (uint256 x, uint256 y) internal pure returns (uint256) {
    unchecked {
        require (y != 0);

        uint256 xInt = x>>128;
        uint256 xDecimal = x<<128;
        uint256 yInt = y>>128;
        uint256 yDecimal = y<<128;

        uint256 hi = ((uint256(xInt) << 64)/yInt)<<64;
        uint256 lo = ((uint256(xDecimal)<<64)/yDecimal);
        
        require (hi+lo <= MAX_128x128);
        return hi+lo;
    }
}

任何人都知道实现这一目标的最佳方法，甚至只是对如何做的概念解释，这将不胜感激。提前致谢！

Answer 1

好吧，所以我将在这里为下一个家伙发布解决方案。这里的关键是您可以将共同点分解为两个添加剂部分的最明显的事实之一。例如12.525/9.5 =（12/9.5）+（。525/9.5）考虑到这一点，我们有一种方法可以将数字分解为2 UINT256数字，而只是将它们与一些幻想的转移相连。

    function div128x128 (uint256 x, uint256 y) internal pure returns (uint256) {
        unchecked {
            //Require denominator != 0
            require (y != 0);
            // xDec = x & 2**128-1 i.e 128 precision 128 bits of padding on the left
            uint256 xDec = x & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
             //xInt x *2**-128 i.e. 128 precision 128 bits of padding on the right
            uint256 xInt = x >> 128;
            //hi = xInt*2**256-1 /y ==> leave a full uint256 of bits to store the integer representation of the fractional decimal with 128.128 precision
            uint256 hi = xInt*(MAX_128x128/y);
            //xDec*2**256-1 /y ==> leave full uint256 of bits to store the integer representation of fractional decimal with 128.128 precision, right shift 128 bits since output should be the right 128 bits of precision on the output
            uint256 lo = (xDec*(MAX_128x128/y))>>128;
            /*Example: 12.525/9.5 := 12/9.5 + .525/9.5<-- legal to break up a fraction into additive pieces with common deniminator in the example above just padding to fit 128.128 output in a uint256
*/
            require (hi+lo <= MAX_128x128);
            return hi+lo;
        }
    }

这是一种解决方案，只要满足要求标准就可以工作。毫无疑问，需要进行优化的改进。但是我已经在一些实际数据上对此进行了测试，并且似乎准确至128.128精度。