{- math/fp/fp.fc This library provide functions for fixed point math. -} ;; internal functions int __fp_math::ln_36(int _x) impure inline { _x *= __math::ONE_18; int z = muldiv((_x - __math::ONE_36), __math::ONE_36, (_x + __math::ONE_36)); int z_squared = muldiv(z, z, __math::ONE_36); int num = z; int series_sum = num; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 3; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 5; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 7; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 9; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 11; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 13; num = muldiv(num, z_squared, __math::ONE_36); series_sum += num / 15; return series_sum * 2; } int __fp_math::ln(int _a) impure inline { if _a < __math::ONE_18 { return negate(__fp_math::ln(muldiv(__math::ONE_18, __math::ONE_18, _a))); } int sum = 0; if _a >= __math::a0 * __math::ONE_18 { _a /= __math::a0; sum += __math::x0; } if _a >= __math::a1 * __math::ONE_18 { _a /= __math::a1; sum += __math::x1; } sum *= 100; _a *= 100; if _a >= __math::a2 { _a = muldiv(_a, __math::ONE_20, __math::a2); sum += __math::x2; } if _a >= __math::a3 { _a = muldiv(_a, __math::ONE_20, __math::a3); sum += __math::x3; } if _a >= __math::a4 { _a = muldiv(_a, __math::ONE_20, __math::a4); sum += __math::x4; } if _a >= __math::a5 { _a = muldiv(_a, __math::ONE_20, __math::a5); sum += __math::x5; } if _a >= __math::a6 { _a = muldiv(_a, __math::ONE_20, __math::a6); sum += __math::x6; } if _a >= __math::a7 { _a = muldiv(_a, __math::ONE_20, __math::a7); sum += __math::x7; } if _a >= __math::a8 { _a = muldiv(_a, __math::ONE_20, __math::a8); sum += __math::x8; } if _a >= __math::a9 { _a = muldiv(_a, __math::ONE_20, __math::a9); sum += __math::x9; } if _a >= __math::a10 { _a = muldiv(_a, __math::ONE_20, __math::a10); sum += __math::x10; } if _a >= __math::a11 { _a = muldiv(_a, __math::ONE_20, __math::a11); sum += __math::x11; } int z = muldiv((_a - __math::ONE_20), __math::ONE_20, (_a + __math::ONE_20)); int z_squared = muldiv(z, z, __math::ONE_20); int num = z; int series_sum = num; num = muldiv(num, z_squared, __math::ONE_20); series_sum += num / 3; num = muldiv(num, z_squared, __math::ONE_20); series_sum += num / 5; num = muldiv(num, z_squared, __math::ONE_20); series_sum += num / 7; num = muldiv(num, z_squared, __math::ONE_20); series_sum += num / 9; num = muldiv(num, z_squared, __math::ONE_20); series_sum += num / 11; series_sum *= 2; int result = (sum + series_sum) / 100; return result; } ;; public functions int math::fp::mul(int a, int b) inline { return muldiv(a, b, __math::ONE_18); } int math::fp::div(int a, int b) impure inline { throw_if(math::error::zero_division, b == 0); return muldiv(a, __math::ONE_18, b); } int math::fp::mul_up(int a, int b) inline { int product = a * b; ;; The traditional divUp formula is: ;; divUp(x, y) := (x + y - 1) / y ;; To avoid intermediate overflow in the addition, we distribute the division and get: ;; divUp(x, y) := (x - 1) / y + 1 ;; Note that this requires x != 0, if x == 0 then the result is zero return product == 0 ? 0 : ((product - 1) / math::ONE_DEC) + 1; } int math::fp::div_up(int a, int b) inline { throw_if(math::error::zero_division, b == 0); ;; The traditional divUp formula is: ;; divUp(x, y) := (x + y - 1) / y ;; To avoid intermediate overflow in the addition, we distribute the division and get: ;; _divUp(x, y) := (x - 1) / y + 1 ;; Note that this requires x != 0, if x == 0 then the result is zero return a == 0 ? 0 : (a * math::ONE_DEC - 1) / b + 1; } ;; add 18 decimals int math::fp::from(int _x) inline { return _x * __math::ONE_18; } ;; remove 18 decimals (floor) int math::fp::to(int _x) inline { return _x / __math::ONE_18; } ;; remove 18 decimals (ceil) int math::fp::to_ceil(int _x) inline { return _x ^/ __math::ONE_18; } ;; remove 18 decimals (round) int math::fp::to_round(int _x) inline { return _x ~/ __math::ONE_18; } ;; same as regular muldiv because extra __math::ONE_18 cancel each other out in div and mul int math::fp::muldiv(int _x, int _y, int _z) inline { ;; ((x * y / __math::ONE_18) * __math::ONE_18 / z) = x * y / z return muldiv(_x, _y, _z); } ;; _a should have 18 decimals -> returns with 18 decimals int math::fp::ln(int _a) impure inline { if _a == __math::e { return __math::ONE_18; } if _a == __math::ONE_18 { return 0; } throw_unless(math::error::out_of_bounds, _a > 0); if (__math::LN_36_LOWER_BOUND < _a) & (_a < __math::LN_36_UPPER_BOUND) { return __fp_math::ln_36(_a) / __math::ONE_18; } else { return __fp_math::ln(_a); } } ;; _arg and _base should have 18 decimals -> returns with 18 decimals int math::fp::log(int _arg, int _base) impure inline { throw_if(math::error::0_base, _base == 0); if _arg == __math::ONE_18 { return 0; } int log_base = 0; if (__math::LN_36_LOWER_BOUND < _base) & (_base < __math::LN_36_UPPER_BOUND) { log_base = __fp_math::ln_36(_base); } else { log_base = __fp_math::ln(_base) * __math::ONE_18; } int log_arg = 0; if (__math::LN_36_LOWER_BOUND < _arg) & (_arg < __math::LN_36_UPPER_BOUND) { log_arg = __fp_math::ln_36(_arg); } else { log_arg = __fp_math::ln(_arg) * __math::ONE_18; } return muldiv(log_arg, __math::ONE_18, log_base); } ;; _x should have 18 decimals -> returns with 18 decimals int math::fp::exp(int _x) impure inline { if _x == __math::ONE_18 { return __math::e; } throw_unless(math::error::invalid_exponent, (_x >= __math::MIN_NATURAL_EXPONENT) & (_x <= __math::MAX_NATURAL_EXPONENT)); if _x < 0 { return muldiv(__math::ONE_18, __math::ONE_18, math::fp::exp(_x.negate())); } int first_AN = 0; if _x >= __math::x0 { _x -= __math::x0; first_AN = __math::a0; } elseif _x >= __math::x1 { _x -= __math::x1; first_AN = __math::a1; } else { first_AN = 1; } _x *= 100; int product = __math::ONE_20; if _x >= __math::x2 { _x -= __math::x2; product = muldiv(product, __math::a2, __math::ONE_20); } if _x >= __math::x3 { _x -= __math::x3; product = muldiv(product, __math::a3, __math::ONE_20); } if _x >= __math::x4 { _x -= __math::x4; product = muldiv(product, __math::a4, __math::ONE_20); } if _x >= __math::x5 { _x -= __math::x5; product = muldiv(product, __math::a5, __math::ONE_20); } if _x >= __math::x6 { _x -= __math::x6; product = muldiv(product, __math::a6, __math::ONE_20); } if _x >= __math::x7 { _x -= __math::x7; product = muldiv(product, __math::a7, __math::ONE_20); } if _x >= __math::x8 { _x -= __math::x8; product = muldiv(product, __math::a8, __math::ONE_20); } if _x >= __math::x9 { _x -= __math::x9; product = muldiv(product, __math::a9, __math::ONE_20); } int series_sum = __math::ONE_20; int term = _x; series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 2); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 3); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 4); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 5); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 6); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 7); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 8); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 9); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 10); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 11); series_sum += term; term = muldiv(term, _x, __math::ONE_20 * 12); series_sum += term; return muldiv(muldiv(product, series_sum, __math::ONE_20), first_AN, 100); } ;; _x and _y should have 18 decimals -> returns with 18 decimals int math::fp::pow(int _x, int _y) impure inline { if _y == 0 { return __math::ONE_18; } if _x == 0 { return 0; } if _x == __math::ONE_18 { return __math::ONE_18; } throw_unless(math::error::x_out_of_bounds, _x >> 256 == 0); throw_unless(math::error::y_out_of_bounds, _y < __math::MILD_EXPONENT_BOUND); int logx_times_y = 0; if (__math::LN_36_LOWER_BOUND < _x) & (_x < __math::LN_36_UPPER_BOUND) { int ln_36_x = __fp_math::ln_36(_x); logx_times_y = (ln_36_x / __math::ONE_18) * _y + muldiv(ln_36_x % __math::ONE_18, _y, __math::ONE_18); } else { logx_times_y = __fp_math::ln(_x) * _y; } logx_times_y /= __math::ONE_18; throw_unless(math::error::product_out_of_bounds, (__math::MIN_NATURAL_EXPONENT <= logx_times_y) & (logx_times_y <= __math::MAX_NATURAL_EXPONENT)); return math::fp::exp(logx_times_y); } ;; _x has 18 decimals -> returns with 18 decimals int math::fp::pow_dec(int _x, int _y) impure inline { if _y == 0 { return __math::ONE_18; } if _x == 0 { return 0; } if _x == __math::ONE_18 { return __math::ONE_18; } throw_unless(math::error::negative_power, _y > 0); int res = __math::ONE_18; while _y > 0 { if _y & 1 { res = muldiv(res, _x, __math::ONE_18); } _y = _y >> 1; _x = muldiv(_x, _x, __math::ONE_18); } return res; } int math::fp::complement(int _x) impure inline { throw_if(math::error::cmplment_out_of_range, (_x < 0) | (_x > math::ONE_DEC)); return math::ONE_DEC - _x; } ;; optimized pow for weighted math ;; Returns x^y, assuming both are fixed point numbers, rounding down. The result is guaranteed to not be above ;; the true value (that is, the error function expected - actual is always positive). int math::fp::ow_pow(int x, int y) impure inline { ;; Optimize for when y equals 1.0, 2.0 or 4.0, as those are very simple to implement and occur often in 50/50 ;; and 80/20 Weighted Pools if y == 2 * math::ONE_DEC { return math::fp::mul(x, x); } elseif y == 4 * math::ONE_DEC { int square = math::fp::mul(x, x); return math::fp::mul(square, square); } else { int raw = math::fp::pow(x, y); int maxError = math::fp::mul(raw, __math::max_pow_relative_error) + 1; if raw < maxError { return 0; } else { return raw - maxError; } } } ;; optimized pow_up for weighted math ;; Returns x^y, assuming both are fixed point numbers, rounding up. The result is guaranteed to not be below ;; the true value (that is, the error function expected - actual is always negative). int math::fp::ow_pow_up(int x, int y) impure inline { ;; Optimize for when y equals 1.0, 2.0 or 4.0, as those are very simple to implement and occur often in 50/50 ;; and 80/20 Weighted Pools if y == 2 * math::ONE_DEC { return math::fp::mul(x, x); } elseif y == 4 * math::ONE_DEC { int square = math::fp::mul(x, x); return math::fp::mul(square, square); } else { int raw = math::fp::pow(x, y); int maxError = math::fp::mul(raw, __math::max_pow_relative_error) + 1; return raw + maxError; } }

Contracts/p+L5LEvMvbqqDAg6odqXYrUgIxNCNK3rO3vI5y29EYI=

Verified Sources