@sushiswap/math
Version:
350 lines (334 loc) • 12.3 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
Big: () => Big_default,
Decimal: () => Decimal_default,
FIVE: () => FIVE,
Fraction: () => Fraction_default,
JSBI: () => import_jsbi8.default,
MAX_SAFE_INTEGER: () => MAX_SAFE_INTEGER,
MAX_UINT128: () => MAX_UINT128,
MAX_UINT256: () => MAX_UINT256,
ONE: () => ONE,
Percent: () => Percent_default,
Rounding: () => Rounding_default,
TEN: () => TEN,
THREE: () => THREE,
TWO: () => TWO,
ZERO: () => ZERO,
ZERO_PERCENT: () => ZERO_PERCENT,
_100: () => _100,
_1000: () => _1000,
_10000: () => _10000,
_1e12: () => _1e12,
_1e18: () => _1e18,
_1e6: () => _1e6,
_1e9: () => _1e9,
_997: () => _997,
_9994: () => _9994,
_9995: () => _9995,
difference: () => difference,
maximum: () => maximum,
minimum: () => minimum,
sqrt: () => sqrt
});
module.exports = __toCommonJS(src_exports);
// src/Big.ts
var import_big = __toESM(require("big.js"));
var import_toformat = __toESM(require("toformat"));
import_big.default.strict = true;
var Big_default = (0, import_toformat.default)(import_big.default);
// src/constants/numbers.ts
var import_jsbi3 = __toESM(require("jsbi"));
// src/Percent.ts
var import_jsbi2 = __toESM(require("jsbi"));
// src/Fraction.ts
var import_jsbi = __toESM(require("jsbi"));
var import_tiny_invariant = __toESM(require("tiny-invariant"));
// src/Decimal.ts
var import_decimal = __toESM(require("decimal.js-light"));
var import_toformat2 = __toESM(require("toformat"));
var Decimal_default = (0, import_toformat2.default)(import_decimal.default);
// src/Rounding.ts
var Rounding = /* @__PURE__ */ ((Rounding2) => {
Rounding2[Rounding2["ROUND_DOWN"] = 0] = "ROUND_DOWN";
Rounding2[Rounding2["ROUND_HALF_UP"] = 1] = "ROUND_HALF_UP";
Rounding2[Rounding2["ROUND_UP"] = 3] = "ROUND_UP";
return Rounding2;
})(Rounding || {});
var Rounding_default = Rounding;
// src/Fraction.ts
var toSignificantRounding = {
[Rounding_default.ROUND_DOWN]: Decimal_default.ROUND_DOWN,
[Rounding_default.ROUND_HALF_UP]: Decimal_default.ROUND_HALF_UP,
[Rounding_default.ROUND_UP]: Decimal_default.ROUND_UP
};
var toFixedRounding = {
[Rounding_default.ROUND_DOWN]: Big_default.roundDown,
[Rounding_default.ROUND_HALF_UP]: Big_default.roundHalfUp,
[Rounding_default.ROUND_UP]: Big_default.roundUp
};
var Fraction = class {
constructor(numerator, denominator = import_jsbi.default.BigInt(1)) {
this.numerator = import_jsbi.default.BigInt(numerator);
this.denominator = import_jsbi.default.BigInt(denominator);
}
static tryParseFraction(fractionish) {
if (fractionish instanceof import_jsbi.default || typeof fractionish === "number" || typeof fractionish === "string")
return new Fraction(fractionish);
if ("numerator" in fractionish && "denominator" in fractionish)
return fractionish;
throw new Error("Could not parse fraction");
}
get quotient() {
return import_jsbi.default.divide(this.numerator, this.denominator);
}
get remainder() {
return new Fraction(import_jsbi.default.remainder(this.numerator, this.denominator), this.denominator);
}
invert() {
return new Fraction(this.denominator, this.numerator);
}
add(other) {
const otherParsed = Fraction.tryParseFraction(other);
if (import_jsbi.default.equal(this.denominator, otherParsed.denominator)) {
return new Fraction(import_jsbi.default.add(this.numerator, otherParsed.numerator), this.denominator);
}
return new Fraction(
import_jsbi.default.add(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(otherParsed.numerator, this.denominator)
),
import_jsbi.default.multiply(this.denominator, otherParsed.denominator)
);
}
subtract(other) {
const otherParsed = Fraction.tryParseFraction(other);
if (import_jsbi.default.equal(this.denominator, otherParsed.denominator)) {
return new Fraction(import_jsbi.default.subtract(this.numerator, otherParsed.numerator), this.denominator);
}
return new Fraction(
import_jsbi.default.subtract(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(otherParsed.numerator, this.denominator)
),
import_jsbi.default.multiply(this.denominator, otherParsed.denominator)
);
}
lessThan(other) {
const otherParsed = Fraction.tryParseFraction(other);
return import_jsbi.default.lessThan(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(otherParsed.numerator, this.denominator)
);
}
equalTo(other) {
const otherParsed = Fraction.tryParseFraction(other);
return import_jsbi.default.equal(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(otherParsed.numerator, this.denominator)
);
}
greaterThan(other) {
const otherParsed = Fraction.tryParseFraction(other);
return import_jsbi.default.greaterThan(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(otherParsed.numerator, this.denominator)
);
}
multiply(other) {
const otherParsed = Fraction.tryParseFraction(other);
return new Fraction(
import_jsbi.default.multiply(this.numerator, otherParsed.numerator),
import_jsbi.default.multiply(this.denominator, otherParsed.denominator)
);
}
divide(other) {
const otherParsed = Fraction.tryParseFraction(other);
return new Fraction(
import_jsbi.default.multiply(this.numerator, otherParsed.denominator),
import_jsbi.default.multiply(this.denominator, otherParsed.numerator)
);
}
toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = Rounding_default.ROUND_HALF_UP) {
(0, import_tiny_invariant.default)(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
(0, import_tiny_invariant.default)(significantDigits > 0, `${significantDigits} is not positive.`);
Decimal_default.set({
precision: significantDigits + 1,
rounding: toSignificantRounding[rounding]
});
const quotient = new Decimal_default(this.numerator.toString()).div(this.denominator.toString()).toSignificantDigits(significantDigits);
return quotient.toFormat(quotient.decimalPlaces(), format);
}
toFixed(decimalPlaces, format = { groupSeparator: "" }, rounding = Rounding_default.ROUND_HALF_UP) {
(0, import_tiny_invariant.default)(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
(0, import_tiny_invariant.default)(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
Big_default.DP = decimalPlaces;
Big_default.RM = toFixedRounding[rounding];
return new Big_default(this.numerator.toString()).div(this.denominator.toString()).toFormat(decimalPlaces, format);
}
get asFraction() {
return new Fraction(this.numerator, this.denominator);
}
};
var Fraction_default = Fraction;
// src/Percent.ts
var ONE_HUNDRED = new Fraction_default(import_jsbi2.default.BigInt(100));
function toPercent(fraction) {
return new Percent(fraction.numerator, fraction.denominator);
}
var Percent = class extends Fraction_default {
constructor() {
super(...arguments);
this.isPercent = true;
}
add(other) {
return toPercent(super.add(other));
}
subtract(other) {
return toPercent(super.subtract(other));
}
multiply(other) {
return toPercent(super.multiply(other));
}
divide(other) {
return toPercent(super.divide(other));
}
toSignificant(significantDigits = 5, format, rounding) {
return super.multiply(ONE_HUNDRED).toSignificant(significantDigits, format, rounding);
}
toFixed(decimalPlaces = 2, format, rounding) {
return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
}
};
var Percent_default = Percent;
// src/constants/numbers.ts
var ZERO = import_jsbi3.default.BigInt(0);
var ONE = import_jsbi3.default.BigInt(1);
var TWO = import_jsbi3.default.BigInt(2);
var THREE = import_jsbi3.default.BigInt(3);
var FIVE = import_jsbi3.default.BigInt(5);
var TEN = import_jsbi3.default.BigInt(10);
var _100 = import_jsbi3.default.BigInt(100);
var _997 = import_jsbi3.default.BigInt(997);
var _1000 = import_jsbi3.default.BigInt(1e3);
var _9994 = import_jsbi3.default.BigInt(9994);
var _9995 = import_jsbi3.default.BigInt(9995);
var _10000 = import_jsbi3.default.BigInt(1e4);
var _1e18 = import_jsbi3.default.BigInt(1e18);
var _1e12 = import_jsbi3.default.BigInt(1e12);
var _1e9 = import_jsbi3.default.BigInt(1e9);
var _1e6 = import_jsbi3.default.BigInt(1e6);
var MAX_SAFE_INTEGER = import_jsbi3.default.BigInt(Number.MAX_SAFE_INTEGER);
var MAX_UINT256 = import_jsbi3.default.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
var MAX_UINT128 = import_jsbi3.default.subtract(import_jsbi3.default.exponentiate(import_jsbi3.default.BigInt("2"), import_jsbi3.default.BigInt(128)), import_jsbi3.default.BigInt(1));
var ZERO_PERCENT = new Percent_default(0);
// src/functions/difference.ts
var import_jsbi4 = __toESM(require("jsbi"));
function difference(a, b) {
if (import_jsbi4.default.greaterThan(a, b)) {
return import_jsbi4.default.subtract(a, b);
}
return import_jsbi4.default.subtract(b, a);
}
// src/functions/maximum.ts
var import_jsbi5 = __toESM(require("jsbi"));
function maximum(...values) {
let highest = values[0];
for (let i = 1; i < values.length; i++) {
const value = values[i];
if (import_jsbi5.default.GT(value, highest)) {
highest = value;
}
}
return highest;
}
// src/functions/minimum.ts
var import_jsbi6 = __toESM(require("jsbi"));
function minimum(...values) {
let lowest = values[0];
for (let i = 1; i < values.length; i++) {
const value = values[i];
if (import_jsbi6.default.LT(value, lowest)) {
lowest = value;
}
}
return lowest;
}
// src/functions/sqrt.ts
var import_jsbi7 = __toESM(require("jsbi"));
var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
function sqrt(value) {
(0, import_tiny_invariant2.default)(import_jsbi7.default.greaterThanOrEqual(value, ZERO), "NEGATIVE");
if (import_jsbi7.default.lessThan(value, MAX_SAFE_INTEGER)) {
return import_jsbi7.default.BigInt(Math.floor(Math.sqrt(import_jsbi7.default.toNumber(value))));
}
let z;
let x;
z = value;
x = import_jsbi7.default.add(import_jsbi7.default.divide(value, TWO), ONE);
while (import_jsbi7.default.lessThan(x, z)) {
z = x;
x = import_jsbi7.default.divide(import_jsbi7.default.add(import_jsbi7.default.divide(value, x), x), TWO);
}
return z;
}
// src/index.ts
var import_jsbi8 = __toESM(require("jsbi"));
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
Big,
Decimal,
FIVE,
Fraction,
JSBI,
MAX_SAFE_INTEGER,
MAX_UINT128,
MAX_UINT256,
ONE,
Percent,
Rounding,
TEN,
THREE,
TWO,
ZERO,
ZERO_PERCENT,
_100,
_1000,
_10000,
_1e12,
_1e18,
_1e6,
_1e9,
_997,
_9994,
_9995,
difference,
maximum,
minimum,
sqrt
});