// SPDX-License-Identifier: Unlicensepragmasolidity >=0.8.4;/// @notice Emitted when the result overflows uint256.errorPRBMath__MulDivFixedPointOverflow(uint256 prod1);
/// @notice Emitted when the result overflows uint256.errorPRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);
/// @notice Emitted when one of the inputs is type(int256).min.errorPRBMath__MulDivSignedInputTooSmall();
/// @notice Emitted when the intermediary absolute result overflows int256.errorPRBMath__MulDivSignedOverflow(uint256 rAbs);
/// @notice Emitted when the input is MIN_SD59x18.errorPRBMathSD59x18__AbsInputTooSmall();
/// @notice Emitted when ceiling a number overflows SD59x18.errorPRBMathSD59x18__CeilOverflow(int256 x);
/// @notice Emitted when one of the inputs is MIN_SD59x18.errorPRBMathSD59x18__DivInputTooSmall();
/// @notice Emitted when one of the intermediary unsigned results overflows SD59x18.errorPRBMathSD59x18__DivOverflow(uint256 rAbs);
/// @notice Emitted when the input is greater than 133.084258667509499441.errorPRBMathSD59x18__ExpInputTooBig(int256 x);
/// @notice Emitted when the input is greater than 192.errorPRBMathSD59x18__Exp2InputTooBig(int256 x);
/// @notice Emitted when flooring a number underflows SD59x18.errorPRBMathSD59x18__FloorUnderflow(int256 x);
/// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18.errorPRBMathSD59x18__FromIntOverflow(int256 x);
/// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18.errorPRBMathSD59x18__FromIntUnderflow(int256 x);
/// @notice Emitted when the product of the inputs is negative.errorPRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);
/// @notice Emitted when multiplying the inputs overflows SD59x18.errorPRBMathSD59x18__GmOverflow(int256 x, int256 y);
/// @notice Emitted when the input is less than or equal to zero.errorPRBMathSD59x18__LogInputTooSmall(int256 x);
/// @notice Emitted when one of the inputs is MIN_SD59x18.errorPRBMathSD59x18__MulInputTooSmall();
/// @notice Emitted when the intermediary absolute result overflows SD59x18.errorPRBMathSD59x18__MulOverflow(uint256 rAbs);
/// @notice Emitted when the intermediary absolute result overflows SD59x18.errorPRBMathSD59x18__PowuOverflow(uint256 rAbs);
/// @notice Emitted when the input is negative.errorPRBMathSD59x18__SqrtNegativeInput(int256 x);
/// @notice Emitted when the calculating the square root overflows SD59x18.errorPRBMathSD59x18__SqrtOverflow(int256 x);
/// @notice Emitted when addition overflows UD60x18.errorPRBMathUD60x18__AddOverflow(uint256 x, uint256 y);
/// @notice Emitted when ceiling a number overflows UD60x18.errorPRBMathUD60x18__CeilOverflow(uint256 x);
/// @notice Emitted when the input is greater than 133.084258667509499441.errorPRBMathUD60x18__ExpInputTooBig(uint256 x);
/// @notice Emitted when the input is greater than 192.errorPRBMathUD60x18__Exp2InputTooBig(uint256 x);
/// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18.errorPRBMathUD60x18__FromUintOverflow(uint256 x);
/// @notice Emitted when multiplying the inputs overflows UD60x18.errorPRBMathUD60x18__GmOverflow(uint256 x, uint256 y);
/// @notice Emitted when the input is less than 1.errorPRBMathUD60x18__LogInputTooSmall(uint256 x);
/// @notice Emitted when the calculating the square root overflows UD60x18.errorPRBMathUD60x18__SqrtOverflow(uint256 x);
/// @notice Emitted when subtraction underflows UD60x18.errorPRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);
/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point/// representation. When it does not, it is explicitly mentioned in the NatSpec documentation.libraryPRBMath{
/// STRUCTS ///structSD59x18 {
int256 value;
}
structUD60x18 {
uint256 value;
}
/// STORAGE ////// @dev How many trailing decimals can be represented.uint256internalconstant SCALE =1e18;
/// @dev Largest power of two divisor of SCALE.uint256internalconstant SCALE_LPOTD =262144;
/// @dev SCALE inverted mod 2^256.uint256internalconstant SCALE_INVERSE =78156646155174841979727994598816262306175212592076161876661_508869554232690281;
/// FUNCTIONS ////// @notice Calculates the binary exponent of x using the binary fraction method./// @dev Has to use 192.64-bit fixed-point numbers./// See https://ethereum.stackexchange.com/a/96594/24693./// @param x The exponent as an unsigned 192.64-bit fixed-point number./// @return result The result as an unsigned 60.18-decimal fixed-point number.functionexp2(uint256 x) internalpurereturns (uint256 result) {
unchecked {
// Start from 0.5 in the 192.64-bit fixed-point format.
result =0x800000000000000000000000000000000000000000000000;
// Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows// because the initial result is 2^191 and all magic factors are less than 2^65.if (x &0x8000000000000000>0) {
result = (result *0x16A09E667F3BCC909) >>64;
}
if (x &0x4000000000000000>0) {
result = (result *0x1306FE0A31B7152DF) >>64;
}
if (x &0x2000000000000000>0) {
result = (result *0x1172B83C7D517ADCE) >>64;
}
if (x &0x1000000000000000>0) {
result = (result *0x10B5586CF9890F62A) >>64;
}
if (x &0x800000000000000>0) {
result = (result *0x1059B0D31585743AE) >>64;
}
if (x &0x400000000000000>0) {
result = (result *0x102C9A3E778060EE7) >>64;
}
if (x &0x200000000000000>0) {
result = (result *0x10163DA9FB33356D8) >>64;
}
if (x &0x100000000000000>0) {
result = (result *0x100B1AFA5ABCBED61) >>64;
}
if (x &0x80000000000000>0) {
result = (result *0x10058C86DA1C09EA2) >>64;
}
if (x &0x40000000000000>0) {
result = (result *0x1002C605E2E8CEC50) >>64;
}
if (x &0x20000000000000>0) {
result = (result *0x100162F3904051FA1) >>64;
}
if (x &0x10000000000000>0) {
result = (result *0x1000B175EFFDC76BA) >>64;
}
if (x &0x8000000000000>0) {
result = (result *0x100058BA01FB9F96D) >>64;
}
if (x &0x4000000000000>0) {
result = (result *0x10002C5CC37DA9492) >>64;
}
if (x &0x2000000000000>0) {
result = (result *0x1000162E525EE0547) >>64;
}
if (x &0x1000000000000>0) {
result = (result *0x10000B17255775C04) >>64;
}
if (x &0x800000000000>0) {
result = (result *0x1000058B91B5BC9AE) >>64;
}
if (x &0x400000000000>0) {
result = (result *0x100002C5C89D5EC6D) >>64;
}
if (x &0x200000000000>0) {
result = (result *0x10000162E43F4F831) >>64;
}
if (x &0x100000000000>0) {
result = (result *0x100000B1721BCFC9A) >>64;
}
if (x &0x80000000000>0) {
result = (result *0x10000058B90CF1E6E) >>64;
}
if (x &0x40000000000>0) {
result = (result *0x1000002C5C863B73F) >>64;
}
if (x &0x20000000000>0) {
result = (result *0x100000162E430E5A2) >>64;
}
if (x &0x10000000000>0) {
result = (result *0x1000000B172183551) >>64;
}
if (x &0x8000000000>0) {
result = (result *0x100000058B90C0B49) >>64;
}
if (x &0x4000000000>0) {
result = (result *0x10000002C5C8601CC) >>64;
}
if (x &0x2000000000>0) {
result = (result *0x1000000162E42FFF0) >>64;
}
if (x &0x1000000000>0) {
result = (result *0x10000000B17217FBB) >>64;
}
if (x &0x800000000>0) {
result = (result *0x1000000058B90BFCE) >>64;
}
if (x &0x400000000>0) {
result = (result *0x100000002C5C85FE3) >>64;
}
if (x &0x200000000>0) {
result = (result *0x10000000162E42FF1) >>64;
}
if (x &0x100000000>0) {
result = (result *0x100000000B17217F8) >>64;
}
if (x &0x80000000>0) {
result = (result *0x10000000058B90BFC) >>64;
}
if (x &0x40000000>0) {
result = (result *0x1000000002C5C85FE) >>64;
}
if (x &0x20000000>0) {
result = (result *0x100000000162E42FF) >>64;
}
if (x &0x10000000>0) {
result = (result *0x1000000000B17217F) >>64;
}
if (x &0x8000000>0) {
result = (result *0x100000000058B90C0) >>64;
}
if (x &0x4000000>0) {
result = (result *0x10000000002C5C860) >>64;
}
if (x &0x2000000>0) {
result = (result *0x1000000000162E430) >>64;
}
if (x &0x1000000>0) {
result = (result *0x10000000000B17218) >>64;
}
if (x &0x800000>0) {
result = (result *0x1000000000058B90C) >>64;
}
if (x &0x400000>0) {
result = (result *0x100000000002C5C86) >>64;
}
if (x &0x200000>0) {
result = (result *0x10000000000162E43) >>64;
}
if (x &0x100000>0) {
result = (result *0x100000000000B1721) >>64;
}
if (x &0x80000>0) {
result = (result *0x10000000000058B91) >>64;
}
if (x &0x40000>0) {
result = (result *0x1000000000002C5C8) >>64;
}
if (x &0x20000>0) {
result = (result *0x100000000000162E4) >>64;
}
if (x &0x10000>0) {
result = (result *0x1000000000000B172) >>64;
}
if (x &0x8000>0) {
result = (result *0x100000000000058B9) >>64;
}
if (x &0x4000>0) {
result = (result *0x10000000000002C5D) >>64;
}
if (x &0x2000>0) {
result = (result *0x1000000000000162E) >>64;
}
if (x &0x1000>0) {
result = (result *0x10000000000000B17) >>64;
}
if (x &0x800>0) {
result = (result *0x1000000000000058C) >>64;
}
if (x &0x400>0) {
result = (result *0x100000000000002C6) >>64;
}
if (x &0x200>0) {
result = (result *0x10000000000000163) >>64;
}
if (x &0x100>0) {
result = (result *0x100000000000000B1) >>64;
}
if (x &0x80>0) {
result = (result *0x10000000000000059) >>64;
}
if (x &0x40>0) {
result = (result *0x1000000000000002C) >>64;
}
if (x &0x20>0) {
result = (result *0x10000000000000016) >>64;
}
if (x &0x10>0) {
result = (result *0x1000000000000000B) >>64;
}
if (x &0x8>0) {
result = (result *0x10000000000000006) >>64;
}
if (x &0x4>0) {
result = (result *0x10000000000000003) >>64;
}
if (x &0x2>0) {
result = (result *0x10000000000000001) >>64;
}
if (x &0x1>0) {
result = (result *0x10000000000000001) >>64;
}
// We're doing two things at the same time://// 1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for// the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191// rather than 192.// 2. Convert the result to the unsigned 60.18-decimal fixed-point format.//// This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n".
result *= SCALE;
result >>= (191- (x >>64));
}
}
/// @notice Finds the zero-based index of the first one in the binary representation of x./// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set/// @param x The uint256 number for which to find the index of the most significant bit./// @return msb The index of the most significant bit as an uint256.functionmostSignificantBit(uint256 x) internalpurereturns (uint256 msb) {
if (x >=2**128) {
x >>=128;
msb +=128;
}
if (x >=2**64) {
x >>=64;
msb +=64;
}
if (x >=2**32) {
x >>=32;
msb +=32;
}
if (x >=2**16) {
x >>=16;
msb +=16;
}
if (x >=2**8) {
x >>=8;
msb +=8;
}
if (x >=2**4) {
x >>=4;
msb +=4;
}
if (x >=2**2) {
x >>=2;
msb +=2;
}
if (x >=2**1) {
// No need to shift x any more.
msb +=1;
}
}
/// @notice Calculates floor(x*y÷denominator) with full precision.////// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.////// Requirements:/// - The denominator cannot be zero./// - The result must fit within uint256.////// Caveats:/// - This function does not work with fixed-point numbers.////// @param x The multiplicand as an uint256./// @param y The multiplier as an uint256./// @param denominator The divisor as an uint256./// @return result The result as an uint256.functionmulDiv(uint256 x,
uint256 y,
uint256 denominator
) internalpurereturns (uint256 result) {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256// variables such that product = prod1 * 2^256 + prod0.uint256 prod0; // Least significant 256 bits of the productuint256 prod1; // Most significant 256 bits of the productassembly {
let mm :=mulmod(x, y, not(0))
prod0 :=mul(x, y)
prod1 :=sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.if (prod1 ==0) {
unchecked {
result = prod0 / denominator;
}
return result;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.if (prod1 >= denominator) {
revert PRBMath__MulDivOverflow(prod1, denominator);
}
///////////////////////////////////////////////// 512 by 256 division.///////////////////////////////////////////////// Make division exact by subtracting the remainder from [prod1 prod0].uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder :=mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 :=sub(prod1, gt(remainder, prod0))
prod0 :=sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.// See https://cs.stackexchange.com/q/138556/92363.unchecked {
// Does not overflow because the denominator cannot be zero at this stage in the function.uint256 lpotdod = denominator & (~denominator +1);
assembly {
// Divide denominator by lpotdod.
denominator :=div(denominator, lpotdod)
// Divide [prod1 prod0] by lpotdod.
prod0 :=div(prod0, lpotdod)
// Flip lpotdod such that it is 2^256 / lpotdod. If lpotdod is zero, then it becomes one.
lpotdod :=add(div(sub(0, lpotdod), lpotdod), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * lpotdod;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for// four bits. That is, denominator * inv = 1 mod 2^4.uint256 inverse = (3* denominator) ^2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works// in modular arithmetic, doubling the correct bits in each step.
inverse *=2- denominator * inverse; // inverse mod 2^8
inverse *=2- denominator * inverse; // inverse mod 2^16
inverse *=2- denominator * inverse; // inverse mod 2^32
inverse *=2- denominator * inverse; // inverse mod 2^64
inverse *=2- denominator * inverse; // inverse mod 2^128
inverse *=2- denominator * inverse; // inverse mod 2^256// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1// is no longer required.
result = prod0 * inverse;
return result;
}
}
/// @notice Calculates floor(x*y÷1e18) with full precision.////// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the/// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of/// being rounded to 1e-18. See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.////// Requirements:/// - The result must fit within uint256.////// Caveats:/// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works./// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:/// 1. x * y = type(uint256).max * SCALE/// 2. (x * y) % SCALE >= SCALE / 2////// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number./// @param y The multiplier as an unsigned 60.18-decimal fixed-point number./// @return result The result as an unsigned 60.18-decimal fixed-point number.functionmulDivFixedPoint(uint256 x, uint256 y) internalpurereturns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly {
let mm :=mulmod(x, y, not(0))
prod0 :=mul(x, y)
prod1 :=sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 >= SCALE) {
revert PRBMath__MulDivFixedPointOverflow(prod1);
}
uint256 remainder;
uint256 roundUpUnit;
assembly {
remainder :=mulmod(x, y, SCALE)
roundUpUnit :=gt(remainder, 499999999999999999)
}
if (prod1 ==0) {
unchecked {
result = (prod0 / SCALE) + roundUpUnit;
return result;
}
}
assembly {
result :=add(
mul(
or(
div(sub(prod0, remainder), SCALE_LPOTD),
mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
),
SCALE_INVERSE
),
roundUpUnit
)
}
}
/// @notice Calculates floor(x*y÷denominator) with full precision.////// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately.////// Requirements:/// - None of the inputs can be type(int256).min./// - The result must fit within int256.////// @param x The multiplicand as an int256./// @param y The multiplier as an int256./// @param denominator The divisor as an int256./// @return result The result as an int256.functionmulDivSigned(int256 x,
int256 y,
int256 denominator
) internalpurereturns (int256 result) {
if (x ==type(int256).min|| y ==type(int256).min|| denominator ==type(int256).min) {
revert PRBMath__MulDivSignedInputTooSmall();
}
// Get hold of the absolute values of x, y and the denominator.uint256 ax;
uint256 ay;
uint256 ad;
unchecked {
ax = x <0 ? uint256(-x) : uint256(x);
ay = y <0 ? uint256(-y) : uint256(y);
ad = denominator <0 ? uint256(-denominator) : uint256(denominator);
}
// Compute the absolute value of (x*y)÷denominator. The result must fit within int256.uint256 rAbs = mulDiv(ax, ay, ad);
if (rAbs >uint256(type(int256).max)) {
revert PRBMath__MulDivSignedOverflow(rAbs);
}
// Get the signs of x, y and the denominator.uint256 sx;
uint256 sy;
uint256 sd;
assembly {
sx :=sgt(x, sub(0, 1))
sy :=sgt(y, sub(0, 1))
sd :=sgt(denominator, sub(0, 1))
}
// XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs.// If yes, the result should be negative.
result = sx ^ sy ^ sd ==0 ? -int256(rAbs) : int256(rAbs);
}
/// @notice Calculates the square root of x, rounding down./// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.////// Caveats:/// - This function does not work with fixed-point numbers.////// @param x The uint256 number for which to calculate the square root./// @return result The result as an uint256.functionsqrt(uint256 x) internalpurereturns (uint256 result) {
if (x ==0) {
return0;
}
// Set the initial guess to the least power of two that is greater than or equal to sqrt(x).uint256 xAux =uint256(x);
result =1;
if (xAux >=0x100000000000000000000000000000000) {
xAux >>=128;
result <<=64;
}
if (xAux >=0x10000000000000000) {
xAux >>=64;
result <<=32;
}
if (xAux >=0x100000000) {
xAux >>=32;
result <<=16;
}
if (xAux >=0x10000) {
xAux >>=16;
result <<=8;
}
if (xAux >=0x100) {
xAux >>=8;
result <<=4;
}
if (xAux >=0x10) {
xAux >>=4;
result <<=2;
}
if (xAux >=0x8) {
result <<=1;
}
// The operations can never overflow because the result is max 2^127 when it enters this block.unchecked {
result = (result + x / result) >>1;
result = (result + x / result) >>1;
result = (result + x / result) >>1;
result = (result + x / result) >>1;
result = (result + x / result) >>1;
result = (result + x / result) >>1;
result = (result + x / result) >>1; // Seven iterations should be enoughuint256 roundedDownResult = x / result;
return result >= roundedDownResult ? roundedDownResult : result;
}
}
}
Contract Source Code
File 4 of 8: PRBMathUD60x18.sol
// SPDX-License-Identifier: Unlicensepragmasolidity >=0.8.4;import"./PRBMath.sol";
/// @title PRBMathUD60x18/// @author Paul Razvan Berg/// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the/// maximum values permitted by the Solidity type uint256.libraryPRBMathUD60x18{
/// @dev Half the SCALE number.uint256internalconstant HALF_SCALE =5e17;
/// @dev log2(e) as an unsigned 60.18-decimal fixed-point number.uint256internalconstant LOG2_E =1_442695040888963407;
/// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have.uint256internalconstant MAX_UD60x18 =115792089237316195423570985008687907853269984665640564039457_584007913129639935;
/// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have.uint256internalconstant MAX_WHOLE_UD60x18 =115792089237316195423570985008687907853269984665640564039457_000000000000000000;
/// @dev How many trailing decimals can be represented.uint256internalconstant SCALE =1e18;
/// @notice Calculates the arithmetic average of x and y, rounding down./// @param x The first operand as an unsigned 60.18-decimal fixed-point number./// @param y The second operand as an unsigned 60.18-decimal fixed-point number./// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number.functionavg(uint256 x, uint256 y) internalpurereturns (uint256 result) {
// The operations can never overflow.unchecked {
// The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need// to do this because if both numbers are odd, the 0.5 remainder gets truncated twice.
result = (x >>1) + (y >>1) + (x & y &1);
}
}
/// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x.////// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts./// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.////// Requirements:/// - x must be less than or equal to MAX_WHOLE_UD60x18.////// @param x The unsigned 60.18-decimal fixed-point number to ceil./// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number.functionceil(uint256 x) internalpurereturns (uint256 result) {
if (x > MAX_WHOLE_UD60x18) {
revert PRBMathUD60x18__CeilOverflow(x);
}
assembly {
// Equivalent to "x % SCALE" but faster.let remainder :=mod(x, SCALE)
// Equivalent to "SCALE - remainder" but faster.let delta :=sub(SCALE, remainder)
// Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster.
result :=add(x, mul(delta, gt(remainder, 0)))
}
}
/// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number.////// @dev Uses mulDiv to enable overflow-safe multiplication and division.////// Requirements:/// - The denominator cannot be zero.////// @param x The numerator as an unsigned 60.18-decimal fixed-point number./// @param y The denominator as an unsigned 60.18-decimal fixed-point number./// @param result The quotient as an unsigned 60.18-decimal fixed-point number.functiondiv(uint256 x, uint256 y) internalpurereturns (uint256 result) {
result = PRBMath.mulDiv(x, SCALE, y);
}
/// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number./// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant).functione() internalpurereturns (uint256 result) {
result =2_718281828459045235;
}
/// @notice Calculates the natural exponent of x.////// @dev Based on the insight that e^x = 2^(x * log2(e)).////// Requirements:/// - All from "log2"./// - x must be less than 133.084258667509499441.////// @param x The exponent as an unsigned 60.18-decimal fixed-point number./// @return result The result as an unsigned 60.18-decimal fixed-point number.functionexp(uint256 x) internalpurereturns (uint256 result) {
// Without this check, the value passed to "exp2" would be greater than 192.if (x >=133_084258667509499441) {
revert PRBMathUD60x18__ExpInputTooBig(x);
}
// Do the fixed-point multiplication inline to save gas.unchecked {
uint256 doubleScaleProduct = x * LOG2_E;
result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
}
}
/// @notice Calculates the binary exponent of x using the binary fraction method.////// @dev See https://ethereum.stackexchange.com/q/79903/24693.////// Requirements:/// - x must be 192 or less./// - The result must fit within MAX_UD60x18.////// @param x The exponent as an unsigned 60.18-decimal fixed-point number./// @return result The result as an unsigned 60.18-decimal fixed-point number.functionexp2(uint256 x) internalpurereturns (uint256 result) {
// 2^192 doesn't fit within the 192.64-bit format used internally in this function.if (x >=192e18) {
revert PRBMathUD60x18__Exp2InputTooBig(x);
}
unchecked {
// Convert x to the 192.64-bit fixed-point format.uint256 x192x64 = (x <<64) / SCALE;
// Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation.
result = PRBMath.exp2(x192x64);
}
}
/// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x./// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts./// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions./// @param x The unsigned 60.18-decimal fixed-point number to floor./// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number.functionfloor(uint256 x) internalpurereturns (uint256 result) {
assembly {
// Equivalent to "x % SCALE" but faster.let remainder :=mod(x, SCALE)
// Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster.
result :=sub(x, mul(remainder, gt(remainder, 0)))
}
}
/// @notice Yields the excess beyond the floor of x./// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part./// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of./// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number.functionfrac(uint256 x) internalpurereturns (uint256 result) {
assembly {
result :=mod(x, SCALE)
}
}
/// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation.////// @dev Requirements:/// - x must be less than or equal to MAX_UD60x18 divided by SCALE.////// @param x The basic integer to convert./// @param result The same number in unsigned 60.18-decimal fixed-point representation.functionfromUint(uint256 x) internalpurereturns (uint256 result) {
unchecked {
if (x > MAX_UD60x18 / SCALE) {
revert PRBMathUD60x18__FromUintOverflow(x);
}
result = x * SCALE;
}
}
/// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.////// @dev Requirements:/// - x * y must fit within MAX_UD60x18, lest it overflows.////// @param x The first operand as an unsigned 60.18-decimal fixed-point number./// @param y The second operand as an unsigned 60.18-decimal fixed-point number./// @return result The result as an unsigned 60.18-decimal fixed-point number.functiongm(uint256 x, uint256 y) internalpurereturns (uint256 result) {
if (x ==0) {
return0;
}
unchecked {
// Checking for overflow this way is faster than letting Solidity do it.uint256 xy = x * y;
if (xy / x != y) {
revert PRBMathUD60x18__GmOverflow(x, y);
}
// We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE// during multiplication. See the comments within the "sqrt" function.
result = PRBMath.sqrt(xy);
}
}
/// @notice Calculates 1 / x, rounding toward zero.////// @dev Requirements:/// - x cannot be zero.////// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse./// @return result The inverse as an unsigned 60.18-decimal fixed-point number.functioninv(uint256 x) internalpurereturns (uint256 result) {
unchecked {
// 1e36 is SCALE * SCALE.
result =1e36/ x;
}
}
/// @notice Calculates the natural logarithm of x.////// @dev Based on the insight that ln(x) = log2(x) / log2(e).////// Requirements:/// - All from "log2".////// Caveats:/// - All from "log2"./// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision.////// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm./// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number.functionln(uint256 x) internalpurereturns (uint256 result) {
// Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x)// can return is 196205294292027477728.unchecked {
result = (log2(x) * SCALE) / LOG2_E;
}
}
/// @notice Calculates the common logarithm of x.////// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common/// logarithm based on the insight that log10(x) = log2(x) / log2(10).////// Requirements:/// - All from "log2".////// Caveats:/// - All from "log2".////// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm./// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number.functionlog10(uint256 x) internalpurereturns (uint256 result) {
if (x < SCALE) {
revert PRBMathUD60x18__LogInputTooSmall(x);
}
// Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined// in this contract.// prettier-ignoreassembly {
switch x
case1 { result :=mul(SCALE, sub(0, 18)) }
case10 { result :=mul(SCALE, sub(1, 18)) }
case100 { result :=mul(SCALE, sub(2, 18)) }
case1000 { result :=mul(SCALE, sub(3, 18)) }
case10000 { result :=mul(SCALE, sub(4, 18)) }
case100000 { result :=mul(SCALE, sub(5, 18)) }
case1000000 { result :=mul(SCALE, sub(6, 18)) }
case10000000 { result :=mul(SCALE, sub(7, 18)) }
case100000000 { result :=mul(SCALE, sub(8, 18)) }
case1000000000 { result :=mul(SCALE, sub(9, 18)) }
case10000000000 { result :=mul(SCALE, sub(10, 18)) }
case100000000000 { result :=mul(SCALE, sub(11, 18)) }
case1000000000000 { result :=mul(SCALE, sub(12, 18)) }
case10000000000000 { result :=mul(SCALE, sub(13, 18)) }
case100000000000000 { result :=mul(SCALE, sub(14, 18)) }
case1000000000000000 { result :=mul(SCALE, sub(15, 18)) }
case10000000000000000 { result :=mul(SCALE, sub(16, 18)) }
case100000000000000000 { result :=mul(SCALE, sub(17, 18)) }
case1000000000000000000 { result :=0 }
case10000000000000000000 { result := SCALE }
case100000000000000000000 { result :=mul(SCALE, 2) }
case1000000000000000000000 { result :=mul(SCALE, 3) }
case10000000000000000000000 { result :=mul(SCALE, 4) }
case100000000000000000000000 { result :=mul(SCALE, 5) }
case1000000000000000000000000 { result :=mul(SCALE, 6) }
case10000000000000000000000000 { result :=mul(SCALE, 7) }
case100000000000000000000000000 { result :=mul(SCALE, 8) }
case1000000000000000000000000000 { result :=mul(SCALE, 9) }
case10000000000000000000000000000 { result :=mul(SCALE, 10) }
case100000000000000000000000000000 { result :=mul(SCALE, 11) }
case1000000000000000000000000000000 { result :=mul(SCALE, 12) }
case10000000000000000000000000000000 { result :=mul(SCALE, 13) }
case100000000000000000000000000000000 { result :=mul(SCALE, 14) }
case1000000000000000000000000000000000 { result :=mul(SCALE, 15) }
case10000000000000000000000000000000000 { result :=mul(SCALE, 16) }
case100000000000000000000000000000000000 { result :=mul(SCALE, 17) }
case1000000000000000000000000000000000000 { result :=mul(SCALE, 18) }
case10000000000000000000000000000000000000 { result :=mul(SCALE, 19) }
case100000000000000000000000000000000000000 { result :=mul(SCALE, 20) }
case1000000000000000000000000000000000000000 { result :=mul(SCALE, 21) }
case10000000000000000000000000000000000000000 { result :=mul(SCALE, 22) }
case100000000000000000000000000000000000000000 { result :=mul(SCALE, 23) }
case1000000000000000000000000000000000000000000 { result :=mul(SCALE, 24) }
case10000000000000000000000000000000000000000000 { result :=mul(SCALE, 25) }
case100000000000000000000000000000000000000000000 { result :=mul(SCALE, 26) }
case1000000000000000000000000000000000000000000000 { result :=mul(SCALE, 27) }
case10000000000000000000000000000000000000000000000 { result :=mul(SCALE, 28) }
case100000000000000000000000000000000000000000000000 { result :=mul(SCALE, 29) }
case1000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 30) }
case10000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 31) }
case100000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 32) }
case1000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 33) }
case10000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 34) }
case100000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 35) }
case1000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 36) }
case10000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 37) }
case100000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 38) }
case1000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 39) }
case10000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 40) }
case100000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 41) }
case1000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 42) }
case10000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 43) }
case100000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 44) }
case1000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 45) }
case10000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 46) }
case100000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 47) }
case1000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 48) }
case10000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 49) }
case100000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 50) }
case1000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 51) }
case10000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 52) }
case100000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 53) }
case1000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 54) }
case10000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 55) }
case100000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 56) }
case1000000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 57) }
case10000000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 58) }
case100000000000000000000000000000000000000000000000000000000000000000000000000000 { result :=mul(SCALE, 59) }
default {
result := MAX_UD60x18
}
}
if (result == MAX_UD60x18) {
// Do the fixed-point division inline to save gas. The denominator is log2(10).unchecked {
result = (log2(x) * SCALE) /3_321928094887362347;
}
}
}
/// @notice Calculates the binary logarithm of x.////// @dev Based on the iterative approximation algorithm./// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation////// Requirements:/// - x must be greater than or equal to SCALE, otherwise the result would be negative.////// Caveats:/// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation.////// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm./// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.functionlog2(uint256 x) internalpurereturns (uint256 result) {
if (x < SCALE) {
revert PRBMathUD60x18__LogInputTooSmall(x);
}
unchecked {
// Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n).uint256 n = PRBMath.mostSignificantBit(x / SCALE);
// The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow// because n is maximum 255 and SCALE is 1e18.
result = n * SCALE;
// This is y = x * 2^(-n).uint256 y = x >> n;
// If y = 1, the fractional part is zero.if (y == SCALE) {
return result;
}
// Calculate the fractional part via the iterative approximation.// The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.for (uint256 delta = HALF_SCALE; delta >0; delta >>=1) {
y = (y * y) / SCALE;
// Is y^2 > 2 and so in the range [2,4)?if (y >=2* SCALE) {
// Add the 2^(-m) factor to the logarithm.
result += delta;
// Corresponds to z/2 on Wikipedia.
y >>=1;
}
}
}
}
/// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal/// fixed-point number./// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function./// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number./// @param y The multiplier as an unsigned 60.18-decimal fixed-point number./// @return result The product as an unsigned 60.18-decimal fixed-point number.functionmul(uint256 x, uint256 y) internalpurereturns (uint256 result) {
result = PRBMath.mulDivFixedPoint(x, y);
}
/// @notice Returns PI as an unsigned 60.18-decimal fixed-point number.functionpi() internalpurereturns (uint256 result) {
result =3_141592653589793238;
}
/// @notice Raises x to the power of y.////// @dev Based on the insight that x^y = 2^(log2(x) * y).////// Requirements:/// - All from "exp2", "log2" and "mul".////// Caveats:/// - All from "exp2", "log2" and "mul"./// - Assumes 0^0 is 1.////// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number./// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number./// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number.functionpow(uint256 x, uint256 y) internalpurereturns (uint256 result) {
if (x ==0) {
result = y ==0 ? SCALE : uint256(0);
} else {
result = exp2(mul(log2(x), y));
}
}
/// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the/// famous algorithm "exponentiation by squaring".////// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring////// Requirements:/// - The result must fit within MAX_UD60x18.////// Caveats:/// - All from "mul"./// - Assumes 0^0 is 1.////// @param x The base as an unsigned 60.18-decimal fixed-point number./// @param y The exponent as an uint256./// @return result The result as an unsigned 60.18-decimal fixed-point number.functionpowu(uint256 x, uint256 y) internalpurereturns (uint256 result) {
// Calculate the first iteration of the loop in advance.
result = y &1>0 ? x : SCALE;
// Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster.for (y >>=1; y >0; y >>=1) {
x = PRBMath.mulDivFixedPoint(x, x);
// Equivalent to "y % 2 == 1" but faster.if (y &1>0) {
result = PRBMath.mulDivFixedPoint(result, x);
}
}
}
/// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number.functionscale() internalpurereturns (uint256 result) {
result = SCALE;
}
/// @notice Calculates the square root of x, rounding down./// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.////// Requirements:/// - x must be less than MAX_UD60x18 / SCALE.////// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root./// @return result The result as an unsigned 60.18-decimal fixed-point .functionsqrt(uint256 x) internalpurereturns (uint256 result) {
unchecked {
if (x > MAX_UD60x18 / SCALE) {
revert PRBMathUD60x18__SqrtOverflow(x);
}
// Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned// 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root).
result = PRBMath.sqrt(x * SCALE);
}
}
/// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process./// @param x The unsigned 60.18-decimal fixed-point number to convert./// @return result The same number in basic integer form.functiontoUint(uint256 x) internalpurereturns (uint256 result) {
unchecked {
result = x / SCALE;
}
}
}
