PRBMathSD59x18Typed

Smart contract library for advanced fixed-point math that works with int256 numbers considered to have 18 trailing decimals. We call this number representation signed 59.18-decimal fixed-point, since the numbers can have a sign and there can be up to 59 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 int256.

This is the same as PRBMathSD59x18, except that it works with structs instead of raw uint256s.

LOG2_E

int256 LOG2_E

log2(e) as a signed 59.18-decimal fixed-point number.

HALF_SCALE

int256 HALF_SCALE

Half the SCALE number.

MAX_SD59x18

int256 MAX_SD59x18

The maximum value a signed 59.18-decimal fixed-point number can have.

MAX_WHOLE_SD59x18

int256 MAX_WHOLE_SD59x18

The maximum whole value a signed 59.18-decimal fixed-point number can have.

MIN_SD59x18

int256 MIN_SD59x18

The minimum value a signed 59.18-decimal fixed-point number can have.

MIN_WHOLE_SD59x18

int256 MIN_WHOLE_SD59x18

The minimum whole value a signed 59.18-decimal fixed-point number can have.

SCALE

int256 SCALE

How many trailing decimals can be represented.

abs

function abs(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculate the absolute value of x.

Requirements: - x must be greater than MIN_SD59x18.

Name	Type	Description
x	struct PRBMath.SD59x18	The number to calculate the absolute value for.

add

function add(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Adds two signed 59.18-decimal fixed-point numbers together, returning a new signed 59.18-decimal fixed-point number.

Name	Type	Description
x	struct PRBMath.SD59x18	The first summand as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The second summand as a signed 59.18-decimal fixed-point number.

avg

function avg(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the arithmetic average of x and y, rounding down.

Name	Type	Description
x	struct PRBMath.SD59x18	The first operand as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The second operand as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	The arithmetic average as a signed 59.18-decimal fixed-point number.

ceil

function ceil(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Yields the least greatest signed 59.18 decimal fixed-point number greater than or equal to x.

_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_SD59x18._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number to ceil.

div

function div(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Divides two signed 59.18-decimal fixed-point numbers, returning a new signed 59.18-decimal fixed-point number.

_Variant of "mulDiv" that works with signed numbers. Works by computing the signs and the absolute values separately.

Requirements: - All from "PRBMath.mulDiv". - None of the inputs can be type(int256).min. - The denominator cannot be zero. - The result must fit within int256.

Caveats: - All from "PRBMath.mulDiv"._

Name	Type	Description
x	struct PRBMath.SD59x18	The numerator as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The denominator as a signed 59.18-decimal fixed-point number.

e

function e() internal pure returns (struct PRBMath.SD59x18 result)

Returns Euler's number as a signed 59.18-decimal fixed-point number.

See https://en.wikipedia.org/wiki/E(mathematical_constant)._

exp

function exp(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the natural exponent of x.

_Based on the insight that e^x = 2^(x * log2(e)).

Requirements: - All from "log2". - x must be less than 133.084258667509499441.

Caveats: - All from "exp2". - For any x less than -41.446531673892822322, the result is zero._

Name	Type	Description
x	struct PRBMath.SD59x18	The exponent as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	The result as a signed 59.18-decimal fixed-point number.

exp2

function exp2(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the binary exponent of x using the binary fraction method.

_See https://ethereum.stackexchange.com/q/79903/24693.

Requirements: - x must be 192 or less. - The result must fit within MAX_SD59x18.

Caveats: - For any x less than -59.794705707972522261, the result is zero._

Name	Type	Description
x	struct PRBMath.SD59x18	The exponent as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	The result as a signed 59.18-decimal fixed-point number.

floor

function floor(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Yields the greatest signed 59.18 decimal fixed-point number less than or equal to x.

_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 greater than or equal to MIN_WHOLE_SD59x18._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number to floor.

frac

function frac(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Yields the excess beyond the floor of x for positive numbers and the part of the number to the right of the radix point for negative numbers.

Based on the odd function definition. https://en.wikipedia.org/wiki/Fractional_part

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number to get the fractional part of.

fromInt

function fromInt(int256 x) internal pure returns (struct PRBMath.SD59x18 result)

Converts a number from basic integer form to signed 59.18-decimal fixed-point representation.

Requirements: - x must be greater than or equal to MIN_SD59x18 divided by SCALE. - x must be less than or equal to MAX_SD59x18 divided by SCALE.

Name	Type	Description
x	int256	The basic integer to convert.

gm

function gm(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.

Requirements: - x * y must fit within MAX_SD59x18, lest it overflows. - x * y cannot be negative.

Name	Type	Description
x	struct PRBMath.SD59x18	The first operand as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The second operand as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	The result as a signed 59.18-decimal fixed-point number.

inv

function inv(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates 1 / x, rounding toward zero.

Requirements: - x cannot be zero.

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number for which to calculate the inverse.

Name	Type	Description
result	struct PRBMath.SD59x18	The inverse as a signed 59.18-decimal fixed-point number.

ln

function ln(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the natural logarithm of x.

_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 2718281828459045235, for that we would need more fine-grained precision._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number for which to calculate the natural logarithm.

Name	Type	Description
result	struct PRBMath.SD59x18	The natural logarithm as a signed 59.18-decimal fixed-point number.

log10

function log10(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the common logarithm of x.

_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"._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number for which to calculate the common logarithm.

Name	Type	Description
result	struct PRBMath.SD59x18	The common logarithm as a signed 59.18-decimal fixed-point number.

log2

function log2(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the binary logarithm of x.

_Based on the iterative approximation algorithm. https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation

Requirements: - x must be greater than zero.

Caveats: - The results are not perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number for which to calculate the binary logarithm.

Name	Type	Description
result	struct PRBMath.SD59x18	The binary logarithm as a signed 59.18-decimal fixed-point number.

mul

function mul(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Multiplies two signed 59.18-decimal fixed-point numbers together, returning a new signed 59.18-decimal fixed-point number.

_Variant of "mulDiv" that works with signed numbers and employs constant folding, i.e. the denominator is always 1e18.

Requirements: - All from "PRBMath.mulDivFixedPoint". - None of the inputs can be MIN_SD59x18 - The result must fit within MAX_SD59x18.

Caveats: - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works._

Name	Type	Description
x	struct PRBMath.SD59x18	The multiplicand as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The multiplier as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	The product as a signed 59.18-decimal fixed-point number.

pi

function pi() internal pure returns (struct PRBMath.SD59x18 result)

Returns PI as a signed 59.18-decimal fixed-point number.

pow

function pow(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Raises x to the power of y.

_Based on the insight that x^y = 2^(log2(x) * y).

Requirements: - All from "exp2", "log2" and "mul". - z cannot be zero.

Caveats: - All from "exp2", "log2" and "mul". - Assumes 0^0 is 1._

Name	Type	Description
x	struct PRBMath.SD59x18	Number to raise to given power y, as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	Exponent to raise x to, as a signed 59.18-decimal fixed-point number.

Name	Type	Description
result	struct PRBMath.SD59x18	x raised to power y, as a signed 59.18-decimal fixed-point number.

powu

function powu(struct PRBMath.SD59x18 x, uint256 y) internal pure returns (struct PRBMath.SD59x18 result)

Raises x (signed 59.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the famous algorithm "exponentiation by squaring".

_See https://en.wikipedia.org/wiki/Exponentiation_by_squaring

Requirements: - All from "abs" and "PRBMath.mulDivFixedPoint". - The result must fit within MAX_SD59x18.

Caveats: - All from "PRBMath.mulDivFixedPoint". - Assumes 0^0 is 1._

Name	Type	Description
x	struct PRBMath.SD59x18	The base as a signed 59.18-decimal fixed-point number.
y	uint256	The exponent as an uint256.

Name	Type	Description
result	struct PRBMath.SD59x18	The result as a signed 59.18-decimal fixed-point number.

scale

function scale() internal pure returns (struct PRBMath.SD59x18 result)

Returns 1 as a signed 59.18-decimal fixed-point number.

sqrt

function sqrt(struct PRBMath.SD59x18 x) internal pure returns (struct PRBMath.SD59x18 result)

Calculates the square root of x, rounding down.

_Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.

Requirements: - x cannot be negative. - x must be less than MAX_SD59x18 / SCALE._

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number for which to calculate the square root.

Name	Type	Description
result	struct PRBMath.SD59x18	The result as a signed 59.18-decimal fixed-point .

sub

function sub(struct PRBMath.SD59x18 x, struct PRBMath.SD59x18 y) internal pure returns (struct PRBMath.SD59x18 result)

Subtracts one signed 59.18-decimal fixed-point number from another one, returning a new signed 59.18-decimal fixed-point number.

Name	Type	Description
x	struct PRBMath.SD59x18	The minuend as a signed 59.18-decimal fixed-point number.
y	struct PRBMath.SD59x18	The subtrahend as a signed 59.18-decimal fixed-point number.

toInt

function toInt(struct PRBMath.SD59x18 x) internal pure returns (int256 result)

Converts a signed 59.18-decimal fixed-point number to basic integer form, rounding down in the process.

Name	Type	Description
x	struct PRBMath.SD59x18	The signed 59.18-decimal fixed-point number to convert.

Name	Type	Description
result	int256	The same number in basic integer form.