The pow function in UD60x18 does not work with bases lower than 1

[jinqiao0423]

Hi! I'm not very sure about the input lower & upper bounds, as well as precision in some scenarios such as x^y.

My code is something like this:

function testUD60x18Pow(uint base, uint exp) external pure returns (uint) {
    UD60x18 convertedBase = ud(base);
    UD60x18 convertedExp = ud(exp);
    return convertedBase.pow(convertedExp).intoUint256();
}

From the name I assume that UD60x18 is with a 1e18 precision so an 1e18 input is actually 1.
I tried 1 ^ 1 = 1, 0.1^1 = 1, 1^0.1 = 1, fine, but in case of 0.1^0.1, an error occurs:

call to Playground.testUD60x18Pow errored: Internal JSON-RPC error.{
  "code": 1,
  "message": "message execution failed: exit 33, revert reason: 0x36d32ef0000000000000000000000000000000000000000000000000016345785d8a0000, vm error: message failed with backtrace:\n00: f019287 (method 3844450837) -- contract reverted (33)\n (RetCode=33)"
}

I also tried some other cases such as:
1.1^1.1, succeeded
1.000000000000000001^1.000000000000000001, succeeded
10^10, succeeded
100^100, failed
1000^1000,failed
And 0.9^0.9 also failed.. It seems if base and exp are both below 1, tx will revert?
I understand that there must be an upper bounds because of overflow. However, I'm not sure whether there is a lower bounds on UD60x18 in such scenarios. If so, what is the exact lower bound? Thx!

[PaulRBerg]

Hi @jinqiao0423, thank you opening this discussion.

This is not a bug. It's a known limitation of the pow function. If you run the function you posted on Remix, you will see this error reported when passing 0.1^0.1:

Error provided by the contract:
PRBMath_UD60x18_Log_InputTooSmall : Emitted when taking the logarithm of a number less than 1.

The reason for this limitation is that the pow function uses the log2 function under the hood, which does not work for values lower than UNIT (1e18), because the resultant logarithm would be negative. The UD60x18 type does not allow intermediary negative values.

The solution is simple: just use SD59x18 instead of UD60x18, which can handle negative values. This topic has also been discussed here:

#50 (reply in thread)

It seems if base and exp are both below 1, tx will revert?

Actually, the revert happens only when the base is lower than 1 (see the implementation of pow).

[PaulRBerg]

Update: since #182 has been merged, the UD60x18.pow function works with bases lower than 1e18 🎉

Refer to the NatSpec comments for documentation:

prb-math/src/ud60x18/Math.sol

Lines 453 to 481 in 97170d0

	/// @notice Raises x to the power of y.
	///
	/// For $1 \leq x \leq \infty$, the following standard formula is used:
	///
	/// $$
	/// x^y = 2^{log_2{x} * y}
	/// $$
	///
	/// For $0 \leq x \lt 1$, since the unsigned {log2} is undefined, an equivalent formula is used:
	///
	/// $$
	/// i = \frac{1}{x}
	/// w = 2^{log_2{i} * y}
	/// x^y = \frac{1}{w}
	/// $$
	///
	/// @dev Notes:
	/// - Refer to the notes in {log2} and {mul}.
	/// - Returns `UNIT` for 0^0.
	/// - It may not perform well with very small values of x. Consider using SD59x18 as an alternative.
	///
	/// Requirements:
	/// - Refer to the requirements in {exp2}, {log2}, and {mul}.
	///
	/// @param x The base as a UD60x18 number.
	/// @param y The exponent as a UD60x18 number.
	/// @return result The result as a UD60x18 number.
	/// @custom:smtchecker abstract-function-nondet
	function pow(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {