From 8b0cb243ab40d94f13a8af5f7f7f40014afe5c8f Mon Sep 17 00:00:00 2001 From: Viktor Smirnov Date: Sat, 4 Mar 2017 12:32:56 +0300 Subject: [PATCH] Add type definitions for 'bignumber.js' --- bignumber.js/bignumber.js-tests.ts | 445 ++++++++++++++++++ bignumber.js/index.d.ts | 693 +++++++++++++++++++++++++++++ bignumber.js/tsconfig.json | 22 + 3 files changed, 1160 insertions(+) create mode 100644 bignumber.js/bignumber.js-tests.ts create mode 100644 bignumber.js/index.d.ts create mode 100644 bignumber.js/tsconfig.json diff --git a/bignumber.js/bignumber.js-tests.ts b/bignumber.js/bignumber.js-tests.ts new file mode 100644 index 0000000000..3818d79761 --- /dev/null +++ b/bignumber.js/bignumber.js-tests.ts @@ -0,0 +1,445 @@ +var x = new BigNumber(9) +var y = new BigNumber(x) + +BigNumber(435.345) + +new BigNumber('5032485723458348569331745.33434346346912144534543') +new BigNumber('4.321e+4') +new BigNumber('-735.0918e-430') +new BigNumber(Infinity) +new BigNumber(NaN) +new BigNumber('.5') +new BigNumber('+2') +new BigNumber(-10110100.1, 2) +new BigNumber(-0b10110100) +new BigNumber('123412421.234324', 5) +new BigNumber('ff.8', 16) +new BigNumber('0xff.8') + +new BigNumber(9, 2) + +new BigNumber(96517860459076817.4395) + +new BigNumber('blurgh') + +BigNumber.config({ DECIMAL_PLACES: 5 }) +new BigNumber(1.23456789) +new BigNumber(1.23456789, 10) + +BigNumber.config({ DECIMAL_PLACES: 5 }) +var BN = BigNumber.another({ DECIMAL_PLACES: 9 }) + +x = new BigNumber(1) +y = new BN(1) + +x.div(3) +y.div(3) + +BN = BigNumber.another() +BN.config({ DECIMAL_PLACES: 9 }) + +BigNumber.config({ DECIMAL_PLACES: 5 }) +BigNumber.set({ DECIMAL_PLACES: 5 }) +BigNumber.config(5) + +BigNumber.config({ ROUNDING_MODE: 0 }) +BigNumber.config(undefined, BigNumber.ROUND_UP) + +BigNumber.config({ EXPONENTIAL_AT: 2 }) +new BigNumber(12.3) +new BigNumber(123) +new BigNumber(0.123) +new BigNumber(0.0123) + +BigNumber.config({ EXPONENTIAL_AT: [-7, 20] }) +new BigNumber(123456789) +new BigNumber(0.000000123) + +BigNumber.config({ EXPONENTIAL_AT: 1e+9 }) + +BigNumber.config({ EXPONENTIAL_AT: 0 }) + +BigNumber.config({ RANGE: 500 }) +BigNumber.config().RANGE +new BigNumber('9.999e499') +new BigNumber('1e500') +new BigNumber('1e-499') +new BigNumber('1e-500') + +BigNumber.config({ RANGE: [-3, 4] }) +new BigNumber(99999) +new BigNumber(100000) +new BigNumber(0.001) +new BigNumber(0.0001) + +BigNumber.config({ ERRORS: false }) + +BigNumber.config({ CRYPTO: true }) +BigNumber.config().CRYPTO +BigNumber.random() + +BigNumber.config({ MODULO_MODE: BigNumber.EUCLID }) +BigNumber.config({ MODULO_MODE: 9 }) + +BigNumber.config({ POW_PRECISION: 100 }) + +BigNumber.config({ + FORMAT: { + decimalSeparator: '.', + groupSeparator: ',', + groupSize: 3, + secondaryGroupSize: 0, + fractionGroupSeparator: ' ', + fractionGroupSize: 0 + } +}); + +BigNumber.config({ + DECIMAL_PLACES: 40, + ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL, + EXPONENTIAL_AT: [-10, 20], + RANGE: [-500, 500], + ERRORS: true, + CRYPTO: true, + MODULO_MODE: BigNumber.ROUND_FLOOR, + POW_PRECISION: 80, + FORMAT: { + groupSize: 3, + groupSeparator: ' ', + decimalSeparator: ',' + } +}); + +BigNumber.config(40, 7, [-10, 20], 500, 1, 1, 3, 80) + +var obj = BigNumber.config(); +obj.ERRORS +obj.RANGE + +x = new BigNumber('3257869345.0378653') +BigNumber.max(4e9, x, '123456789.9') + +var arr = [12, '13', new BigNumber(14)] +BigNumber.max(arr) + +x = new BigNumber('3257869345.0378653') +BigNumber.min(4e9, x, '123456789.9') + +arr = [2, new BigNumber(-14), '-15.9999', -12] +BigNumber.min(arr) + +BigNumber.config({ DECIMAL_PLACES: 10 }) +BigNumber.random() +BigNumber.random(20) + +BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_CEIL }) +BigNumber.config({ ROUNDING_MODE: 2 }) + +x = new BigNumber(-0.8) +y = x.absoluteValue() +var z = y.abs() + +x = new BigNumber(1.3) +x.ceil() +y = new BigNumber(-1.8) +y.ceil() + +x = new BigNumber(Infinity) +y = new BigNumber(5) +x.comparedTo(y) +x.comparedTo(x.minus(1)) +y.cmp(NaN) +y.cmp('110', 2) + +x = new BigNumber(123.45) +x.decimalPlaces() +y = new BigNumber('9.9e-101') +y.dp() + +x = new BigNumber(355) +y = new BigNumber(113) +x.dividedBy(y) +x.div(5) +x.div(47, 16) + +x = new BigNumber(5) +y = new BigNumber(3) +x.dividedToIntegerBy(y) +x.divToInt(0.7) +x.divToInt('0.f', 16) + +0 === 1e-324 +x = new BigNumber(0) +x.equals('1e-324') +BigNumber(-0).eq(x) +BigNumber(255).eq('ff', 16) + +y = new BigNumber(NaN) +y.equals(NaN) + +x = new BigNumber(1.8) +x.floor() +y = new BigNumber(-1.3) +y.floor() + +0.1 > (0.3 - 0.2) +x = new BigNumber(0.1) +x.greaterThan(BigNumber(0.3).minus(0.2)) +BigNumber(0).gt(x) +BigNumber(11, 3).gt(11.1, 2) + +x = new BigNumber(0.3).minus(0.2) +x.greaterThanOrEqualTo(0.1) +BigNumber(1).gte(x) +BigNumber(10, 18).gte('i', 36) + +x = new BigNumber(1) +x.isFinite() +y = new BigNumber(Infinity) +y.isFinite() + +x = new BigNumber(1) +x.isInteger() +y = new BigNumber(123.456) +y.isInt() + +x = new BigNumber(NaN) +x.isNaN() +y = new BigNumber('Infinity') +y.isNaN() + +x = new BigNumber(-0) +x.isNegative() +y = new BigNumber(2) +y.isNeg() + +x = new BigNumber(-0) +x.isZero() && x.isNeg() +y = new BigNumber(Infinity) +y.isZero() + +x = new BigNumber(0.3).minus(0.2) +x.lessThan(0.1) +BigNumber(0).lt(x) +BigNumber(11.1, 2).lt(11, 3) + +x = new BigNumber(0.1) +x.lessThanOrEqualTo(BigNumber(0.3).minus(0.2)) +BigNumber(-1).lte(x) +BigNumber(10, 18).lte('i', 36) + +x = new BigNumber(0.3) +x.minus(0.1) +x.sub(0.6, 20) + +x = new BigNumber(1) +x.modulo(0.9) +y = new BigNumber(33) +y.mod('a', 33) + +x = new BigNumber(1.8) +x.negated() +y = new BigNumber(-1.3) +y.neg() + +x = new BigNumber(0.1) +y = x.plus(0.2) +BigNumber(0.7).plus(x).add(y) +x.plus('0.1', 8) + +x = new BigNumber(1.234) +x.precision() +y = new BigNumber(987000) +y.sd() +y.sd(true) + +y = new BigNumber(x) +y.round() +y.round(1) +y.round(2) +y.round(10) +y.round(0, 1) +y.round(0, 6) +y.round(1, 1) +y.round(1, BigNumber.ROUND_HALF_EVEN) +y + +x = new BigNumber(1.23) +x.shift(3) +x.shift(-3) + +x = new BigNumber(16) +x.squareRoot() +y = new BigNumber(3) +y.sqrt() + +x = new BigNumber(0.6) +y = x.times(3) +BigNumber('7e+500').times(y) +x.times('-a', 16) + +BigNumber.config({ DECIMAL_PLACES: 5, ROUNDING_MODE: 4 }) +x = new BigNumber(9876.54321) + +x.toDigits() +x.toDigits(6) +x.toDigits(6, BigNumber.ROUND_UP) +x.toDigits(2) +x.toDigits(2, 1) +x + +y = new BigNumber(45.6) +y.toExponential() +y.toExponential(0) +y.toExponential(1) +y.toExponential(1, 1) +y.toExponential(3) + +y = new BigNumber(3.456) +y.toFixed() +y.toFixed(0) +y.toFixed(2) +y.toFixed(2, 1) +y.toFixed(5) + +var format = { + decimalSeparator: '.', + groupSeparator: ',', + groupSize: 3, + secondaryGroupSize: 0, + fractionGroupSeparator: ' ', + fractionGroupSize: 0 +} +BigNumber.config({ FORMAT: format }) + +x = new BigNumber('123456789.123456789') +x.toFormat() +x.toFormat(1) + +format.groupSeparator = ' ' +format.fractionGroupSize = 5 +x.toFormat() + +BigNumber.config({ + FORMAT: { + decimalSeparator: ',', + groupSeparator: '.', + groupSize: 3, + secondaryGroupSize: 2 + } +}) + +x.toFormat(6) + +x = new BigNumber(1.75) +x.toFraction() + +var pi = new BigNumber('3.14159265358') +pi.toFraction() +pi.toFraction(100000) +pi.toFraction(10000) +pi.toFraction(100) +pi.toFraction(10) +pi.toFraction(1) + +x = new BigNumber('177.7e+457') +y = new BigNumber(235.4325) +z = new BigNumber('0.0098074') + +var str = JSON.stringify([x, y, z]) + +JSON.parse(str, (key, val) => key === '' ? val : new BigNumber(val)) + +x = new BigNumber(456.789) +x.toNumber() +{ +x } + +y = new BigNumber('45987349857634085409857349856430985') +y.toNumber() + +z = new BigNumber(-0) +1 / +z +1 / z.toNumber() + +x = new BigNumber(0.7) +x.toPower(2) +BigNumber(3).pow(-2) + +y = new BigNumber(45.6) +x.toPrecision() +y.toPrecision() +x.toPrecision(1) +y.toPrecision(1) +y.toPrecision(2, 0) +y.toPrecision(2, 1) +x.toPrecision(5) +y.toPrecision(5) + +x = new BigNumber(750000) +x.toString() +BigNumber.config({ EXPONENTIAL_AT: 5 }) +x.toString() + +y = new BigNumber(362.875) +y.toString(2) +y.toString(9) +y.toString(32) + +BigNumber.config({ DECIMAL_PLACES: 4 }); +z = new BigNumber('1.23456789') +z.toString() +z.toString(10) + +x = new BigNumber(123.456) +x.truncated() +y = new BigNumber(-12.3) +y.trunc() + +x = new BigNumber('-0') +x.toString() +x.valueOf() +y = new BigNumber('1.777e+457') +y.valueOf() + +x = new BigNumber(0.123) +x.toExponential() +x.c +x.e +x.s + +z = new BigNumber('-123.4567000e+2') +z.toExponential() +z.c +z.e +z.s + +x = new BigNumber(3) +x instanceof BigNumber +x.isBigNumber + +BN = BigNumber.another(); + +y = new BN(3) +y instanceof BigNumber +y.isBigNumber + +y = new BigNumber(-0) +y.c +y.e +y.s + +try { + // ... +} catch (e) { + if (e instanceof Error && e.name == 'BigNumber Error') { + // ... + } +} + +x = new BigNumber("1.0") +y = new BigNumber("1.1000") +z = x.add(y) + +x = new BigNumber("1.20") +y = new BigNumber("3.45000") +z = x.mul(y) diff --git a/bignumber.js/index.d.ts b/bignumber.js/index.d.ts new file mode 100644 index 0000000000..15314f30ec --- /dev/null +++ b/bignumber.js/index.d.ts @@ -0,0 +1,693 @@ +// Type definitions for bignumber.js 4.0 +// Project: https://github.com/MikeMcl/bignumber.js/ +// Definitions by: Viktor Smirnov +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.1 + +declare var BigNumber: bignumber.BigNumberStatic; + +export as namespace BigNumber; +export = BigNumber; + +declare namespace bignumber { + + const enum RoundingMode { + + /** + * Rounds away from zero + */ + ROUND_UP = 0, + + /** + * Rounds towards zero + */ + ROUND_DOWN = 1, + + /** + * Rounds towards `Infinity` + */ + ROUND_CEIL = 2, + + /** + * Rounds towards `-Infinity` + */ + ROUND_FLOOR = 3, + + /** + * Rounds towards nearest neighbour. + * If equidistant, rounds away from zero. + */ + ROUND_HALF_UP = 4, + + /** + * Rounds towards nearest neighbour. + * If equidistant, rounds towards zero. + */ + ROUND_HALF_DOWN = 5, + + /** + * Rounds towards nearest neighbour. + * If equidistant, rounds towards even neighbour. + */ + ROUND_HALF_EVEN = 6, + + /** + * Rounds towards nearest neighbour. + * If equidistant, rounds towards `Infinity`. + */ + ROUND_HALF_CEIL = 7, + + /** + * Rounds towards nearest neighbour. + * If equidistant, rounds towards `-Infinity`. + */ + ROUND_HALF_FLOOR = 8, + + /** + * The remainder is always positive. + * + * Euclidian division: `q = sign(n) * floor(a / abs(n))` + */ + EUCLID = 9, + } + + interface FormatConfig { + + /** + * The decimal separator. + */ + decimalSeparator: string; + + /** + * The grouping separator of the integer part. + */ + groupSeparator: string; + + /** + * The primary grouping size of the integer part. + */ + groupSize: number; + + /** + * The secondary grouping size of the integer part. + */ + secondaryGroupSize: number; + + /** + * The grouping separator of the fraction part. + */ + fractionGroupSeparator: string; + + /** + * The grouping size of the fraction part. + */ + fractionGroupSize: number; + } + + interface BigNumberConfig { + + /** + * The maximum number of decimal places of the results of operations involving division, + * i.e. division, square root and base conversion operations, and power operations with negative exponents. + */ + DECIMAL_PLACES: number; + + /** + * The rounding mode used in the above operations and the default rounding mode of round, `toExponential`, `toFixed`, `toFormat` and `toPrecision`. + */ + ROUNDING_MODE: RoundingMode; + + /** + * The exponent value(s) at which `toString` returns exponential notation. + * + * If a single number is assigned, the value is the exponent magnitude. + * + * If an array of two numbers is assigned then the first number is the negative exponent value at and beneath which exponential notation is used, + * and the second number is the positive exponent value at and above which the same. + */ + EXPONENTIAL_AT: number | number[]; + + /** + * The exponent value(s) beyond which overflow to `Infinity` and underflow to zero occurs. + * + * If a single number is assigned, it is the maximum exponent magnitude: + * values wth a positive exponent of greater magnitude become `Infinity` + * and those with a negative exponent of greater magnitude become zero. + * + * If an array of two numbers is assigned then the first number is the negative exponent limit and the second number is the positive exponent limit. + */ + RANGE: number | number[]; + + /** + * The value that determines whether BigNumber Errors are thrown. + * + * If `ERRORS` is false, no errors will be thrown. + */ + ERRORS: boolean | 0 | 1; + + /** + * The value that determines whether cryptographically-secure pseudo-random number generation is used. + * + * If `CRYPTO` is set to `true` then the `random` method will generate random digits using `crypto.getRandomValues` in browsers that support it, + * or `crypto.randomBytes` if using a version of Node.js that supports it. + * + * If neither function is supported by the host environment then attempting to set `CRYPTO` to `true` will fail, and if `ERRORS` is `true` an exception will be thrown. + * + * If `CRYPTO` is `false` then the source of randomness used will be `Math.random` (which is assumed to generate at least `30` bits of randomness). + */ + CRYPTO: boolean | 0 | 1; + + /** + * The modulo mode used when calculating the modulus: `a mod n`. + * + * The quotient, `q = a / n`, is calculated according to the `ROUNDING_MODE` that corresponds to the chosen `MODULO_MODE`. + * + * The remainder, `r`, is calculated as: `r = a - n * q`. + */ + MODULO_MODE: RoundingMode; + + /** + * The maximum number of significant digits of the result of the power operation (unless a modulus is specified). + * + * If set to `0`, the number of signifcant digits will not be limited. + */ + POW_PRECISION: number; + + /** + * The `FORMAT` object configures the format of the string returned by the toFormat method. + */ + FORMAT: Partial + } + + type NumberLike = number | string | BigNumber; + + interface BigNumberStatic { + + /** + * Returns a new instance of a BigNumber object. + */ + (value: NumberLike, base?: number): BigNumber; + + /** + * Returns a new instance of a BigNumber object. + */ + new (value: NumberLike, base?: number): BigNumber; + + /** + * Returns a new independent BigNumber constructor with configuration as described by obj, or with the default configuration if obj is null or undefined. + */ + another(obj?: Partial): BigNumberStatic; + + /** + * Configures the settings for this particular BigNumber constructor. + * + */ + config(obj?: Partial): BigNumberConfig; + + /** + * Configures the settings for this particular BigNumber constructor. + */ + config( + DECIMAL_PLACES?: number, + ROUNDING_MODE?: RoundingMode, + EXPONENTIAL_AT?: number | number[], + RANGE?: number | number[], + ERRORS?: boolean | 0 | 1, + CRYPTO?: boolean | 0 | 1, + MODULO_MODE?: RoundingMode, + POW_PRECISION?: number + ): BigNumberConfig; + + /** + * Configures the settings for this particular BigNumber constructor. + */ + set(obj?: Partial): BigNumberConfig; + + /** + * Configures the settings for this particular BigNumber constructor. + */ + set( + DECIMAL_PLACES?: number, + ROUNDING_MODE?: RoundingMode, + EXPONENTIAL_AT?: number | number[], + RANGE?: number | number[], + ERRORS?: boolean | 0 | 1, + CRYPTO?: boolean | 0 | 1, + MODULO_MODE?: RoundingMode, + POW_PRECISION?: number + ): BigNumberConfig; + + /** + * Returns a BigNumber whose value is the maximum of `args`. + */ + max(...args: NumberLike[]): BigNumber; + + /** + * Returns a BigNumber whose value is the maximum of `args`. + */ + max(args: NumberLike[]): BigNumber; + + /** + * Returns a BigNumber whose value is the minimum of `args`. + */ + min(...args: NumberLike[]): BigNumber; + + /** + * Returns a BigNumber whose value is the minimum of `args`. + */ + min(args: NumberLike[]): BigNumber; + + /** + * Returns a new BigNumber with a pseudo-random value equal to or greater than `0` and less than `1`. + * + * The return value will have `dp` decimal places (or less if trailing zeros are produced). + * If `dp` is omitted then the number of decimal places will default to the current `DECIMAL_PLACES` setting. + * + * Depending on the value of this BigNumber constructor's `CRYPTO` setting and the support for the `crypto` object in the host environment, + * the random digits of the return value are generated by either + * `Math.random` (fastest), + * `crypto.getRandomValues` (Web Cryptography API in recent browsers) + * or `crypto.randomBytes` (Node.js). + * + * If `CRYPTO` is `true`, i.e. one of the `crypto` methods is to be used, + * the value of a returned BigNumber should be cryptographically-secure and statistically indistinguishable from a random value. + */ + random(dp?: number): BigNumber; + + ROUND_UP: 0; + ROUND_DOWN: 1; + ROUND_CEIL: 2; + ROUND_FLOOR: 3; + ROUND_HALF_UP: 4; + ROUND_HALF_DOWN: 5; + ROUND_HALF_EVEN: 6; + ROUND_HALF_CEIL: 7; + ROUND_HALF_FLOOR: 8; + EUCLID: 9; + } + + interface BigNumber { + + /** + * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this BigNumber. + */ + absoluteValue(): BigNumber; + + /** + * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this BigNumber. + */ + abs(): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber rounded to a whole number in the direction of positive Infinity. + */ + ceil(): BigNumber; + + /** + * Returns + * + * `1` if the value of this BigNumber is greater than the value of `n` + * + * `-1` if the value of this BigNumber is less than the value of `n` + * + * `0` if this BigNumber and `n` have the same value + * + * `null` if the value of either this BigNumber or `n` is `NaN` + */ + comparedTo(n: NumberLike, base?: number): 1 | -1 | 0 | null; + + /** + * Returns + * + * `1` if the value of this BigNumber is greater than the value of `n` + * + * `-1` if the value of this BigNumber is less than the value of `n` + * + * `0` if this BigNumber and `n` have the same value + * + * `null` if the value of either this BigNumber or `n` is `NaN` + */ + cmp(n: NumberLike, base?: number): 1 | -1 | 0 | null; + + /** + * Return the number of decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is `±Infinity` or `NaN`. + */ + decimalPlaces(): number; + + /** + * Return the number of decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is `±Infinity` or `NaN`. + */ + dp(): number; + + /** + * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + */ + dividedBy(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + */ + div(n: NumberLike, base?: number): BigNumber; + + /** + * Return a BigNumber whose value is the integer part of dividing the value of this BigNumber by `n`. + */ + dividedToIntegerBy(n: NumberLike, base?: number): BigNumber; + + /** + * Return a BigNumber whose value is the integer part of dividing the value of this BigNumber by `n`. + */ + divToInt(n: NumberLike, base?: number): BigNumber; + + /** + * Returns `true` if the value of this BigNumber equals the value of `n`, otherwise returns `false`. + * + * As with JavaScript, `NaN` does not equal `NaN`. + */ + equals(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber equals the value of `n`, otherwise returns `false`. + * + * As with JavaScript, `NaN` does not equal `NaN`. + */ + eq(n: NumberLike, base?: number): boolean; + + /** + * Returns a BigNumber whose value is the value of this BigNumber rounded to a whole number in the direction of negative `Infinity`. + */ + floor(): BigNumber; + + /** + * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise returns `false`. + */ + greaterThan(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise returns `false`. + */ + gt(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`, otherwise returns `false`. + */ + greaterThanOrEqualTo(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`, otherwise returns `false`. + */ + gte(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is a finite number, otherwise returns `false`. + * + * The only possible non-finite values of a BigNumber are `NaN`, `Infinity` and `-Infinity`. + */ + isFinite(): boolean; + + /** + * Returns `true` if the value of this BigNumber is a whole number, otherwise returns `false`. + */ + isInteger(): boolean; + + /** + * Returns `true` if the value of this BigNumber is a whole number, otherwise returns `false`. + */ + isInt(): boolean; + + /** + * Returns `true` if the value of this BigNumber is NaN, otherwise returns `false`. + */ + isNaN(): boolean; + + /** + * Returns `true` if the value of this BigNumber is negative, otherwise returns `false`. + */ + isNegative(): boolean; + + /** + * Returns `true` if the value of this BigNumber is negative, otherwise returns `false`. + */ + isNeg(): boolean; + + /** + * Returns `true` if the value of this BigNumber is zero or minus zero, otherwise returns `false`. + */ + isZero(): boolean; + + /** + * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns `false`. + */ + lessThan(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns `false`. + */ + lt(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`, otherwise returns + */ + lessThanOrEqualTo(n: NumberLike, base?: number): boolean; + + /** + * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`, otherwise returns + */ + lte(n: NumberLike, base?: number): boolean; + + /** + * Returns a BigNumber whose value is the value of this BigNumber minus `n`. + */ + minus(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber minus `n`. + */ + sub(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer remainder of dividing this BigNumber by `n`. + * + * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE` setting of this BigNumber constructor. + * If it is `1` (default value), the result will have the same sign as this BigNumber, + * and it will match that of Javascript's `%` operator (within the limits of double precision) and BigDecimal's `remainder` method. + */ + modulo(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer remainder of dividing this BigNumber by `n`. + * + * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE` setting of this BigNumber constructor. + * If it is `1` (default value), the result will have the same sign as this BigNumber, + * and it will match that of Javascript's `%` operator (within the limits of double precision) and BigDecimal's `remainder` method. + */ + mod(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by `-1`. + */ + negated(): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by `-1`. + */ + neg(): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber plus `n`. + */ + plus(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber plus `n`. + */ + add(n: NumberLike, base?: number): BigNumber; + + /** + * Returns the number of significant digits of the value of this BigNumber. + * + * If `z` is `true` or `1` then any trailing zeros of the integer part of a number are counted as significant digits, otherwise they are not. + */ + precision(z?: boolean | 0 | 1): number; + + /** + * Returns the number of significant digits of the value of this BigNumber. + * + * If `z` is `true` or `1` then any trailing zeros of the integer part of a number are counted as significant digits, otherwise they are not. + */ + sd(z?: boolean | 0 | 1): number; + + /** + * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode `rm` to a maximum of `dp` decimal places. + * + * If `dp` is omitted, or is `null` or `undefined`, the return value is `n` rounded to a whole number. + * + * If `rm` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used. + */ + round(dp?: number, rm?: RoundingMode): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber shifted `n` places. + * + * The shift is of the decimal point, i.e. of powers of ten, and is to the left if `n` is negative or to the right if `n` is positive. + */ + shift(n: number): BigNumber; + + /** + * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + * + * The return value will be correctly rounded, i.e. rounded as if the result was first calculated to an infinite number of correct digits before rounding. + */ + squareRoot(): BigNumber; + + /** + * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + * + * The return value will be correctly rounded, i.e. rounded as if the result was first calculated to an infinite number of correct digits before rounding. + */ + sqrt(): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber times `n`. + */ + times(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber times `n`. + */ + mul(n: NumberLike, base?: number): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber rounded to `sd` significant digits using rounding mode `rm`. + * + * If `sd` is omitted or is `null` or `undefined`, the return value will not be rounded. + * + * If `rm` is omitted or is `null` or `undefined`, ROUNDING_MODE will be used. + */ + toDigits(sd?: number, rm?: RoundingMode): BigNumber; + + /** + * Returns a string representing the value of this BigNumber in exponential notation rounded using rounding mode `rm` to `dp` decimal places, + * i.e with one digit before the decimal point and `dp` digits after it. + * + * If the value of this BigNumber in exponential notation has fewer than `dp` fraction digits, the return value will be appended with zeros accordingly. + * + * If `dp` is omitted, or is `null` or `undefined`, the number of digits after the decimal point defaults to the minimum number of digits necessary to represent the value exactly. + * + * If `rm` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. + */ + toExponential(dp?: number, rm?: RoundingMode): string; + + /** + * Returns a string representing the value of this BigNumber in normal (fixed-point) notation rounded to `dp` decimal places using rounding mode `rm`. + * + * If the value of this BigNumber in normal notation has fewer than `dp` fraction digits, the return value will be appended with zeros accordingly. + * + * Unlike `Number.prototype.toFixed`, which returns exponential notation if a number is greater or equal to `10e21`, this method will always return normal notation. + * + * If `dp` is omitted or is `null` or `undefined`, the return value will be unrounded and in normal notation. + * This is also unlike `Number.prototype.toFixed`, which returns the value to zero decimal places. + * It is useful when fixed-point notation is required and the current `EXPONENTIAL_AT` setting causes `toString` to return exponential notation. + * + * If `rm` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. + */ + toFixed(dp?: number, rm?: RoundingMode): string; + + /** + * Returns a string representing the value of this BigNumber in normal (fixed-point) notation rounded to `dp` decimal places using rounding mode `rm`, + * and formatted according to the properties of the `FORMAT` object. + * + * If `dp` is omitted or is `null` or `undefined`, then the return value is not rounded to a fixed number of decimal places. + * + * If `rm` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. + */ + toFormat(dp?: number, rm?: RoundingMode): string; + + /** + * Returns a string array representing the value of this BigNumber as a simple fraction with an integer numerator and an integer denominator. + * The denominator will be a positive non-zero value less than or equal to `max`. + * + * If a maximum denominator, `max`, is not specified, or is `null` or `undefined`, the denominator will be the lowest value necessary to represent the number exactly. + */ + toFraction(max?: NumberLike): [string, string]; + + /** + * As `valueOf`. + */ + toJSON(): string; + + /** + * Returns the value of this BigNumber as a JavaScript number primitive. + * + * Type coercion with, for example, the unary plus operator will also work, except that a BigNumber with the value minus zero will be converted to positive zero. + */ + toNumber(): number; + + /** + * Returns a BigNumber whose value is the value of this BigNumber raised to the power `n`, and optionally modulo a modulus `m`. + * + * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + */ + toPower(n: number, m?: NumberLike): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber raised to the power `n`, and optionally modulo a modulus `m`. + * + * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` configuration. + */ + pow(n: number, m?: NumberLike): BigNumber; + + /** + * Returns a string representing the value of this BigNumber rounded to `sd` significant digits using rounding mode `rm`. + * + * If `sd` is less than the number of digits necessary to represent the integer part of the value in normal (fixed-point) notation, then exponential notation is used. + * + * If `sd` is omitted, or is `null` or `undefined`, then the return value is the same as `n.toString()`. + * + * If `rm` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. + */ + toPrecision(sd?: number, rm?: RoundingMode): string; + + /** + * Returns a string representing the value of this BigNumber in the specified base, or base `10` if `base` is omitted or is `null` or `undefined`. + */ + toString(base?: number): string; + + /** + * Returns a BigNumber whose value is the value of this BigNumber truncated to a whole number. + */ + truncated(): BigNumber; + + /** + * Returns a BigNumber whose value is the value of this BigNumber truncated to a whole number. + */ + trunc(): BigNumber; + + /** + * As `toString`, but does not accept a base argument and includes the minus sign for negative zero. + */ + valueOf(): string; + + /** + * coefficient + * @description Array of base 1e14 numbers + */ + c: number[] | null; + + /** + * exponent + * @description Integer, -1000000000 to 1000000000 inclusive + */ + e: number | null; + + /** + * sign + */ + s: -1 | 1 | null; + + /** + * type identifier + */ + isBigNumber: true; + } +} \ No newline at end of file diff --git a/bignumber.js/tsconfig.json b/bignumber.js/tsconfig.json new file mode 100644 index 0000000000..485dace353 --- /dev/null +++ b/bignumber.js/tsconfig.json @@ -0,0 +1,22 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.d.ts", + "bignumber.js-tests.ts" + ] +} \ No newline at end of file