diff options
Diffstat (limited to 'packages/instant/test')
| -rw-r--r-- | packages/instant/test/util/dependencies/prevbignumber.d.ts | 1772 | ||||
| -rw-r--r-- | packages/instant/test/util/dependencies/prevbignumber.js | 2705 | ||||
| -rw-r--r-- | packages/instant/test/util/maybe_big_number.test.ts | 56 | ||||
| -rw-r--r-- | packages/instant/test/util/order_coercion.test.ts | 103 |
4 files changed, 128 insertions, 4508 deletions
diff --git a/packages/instant/test/util/dependencies/prevbignumber.d.ts b/packages/instant/test/util/dependencies/prevbignumber.d.ts deleted file mode 100644 index 9b802ec3e..000000000 --- a/packages/instant/test/util/dependencies/prevbignumber.d.ts +++ /dev/null @@ -1,1772 +0,0 @@ -// Type definitions for bignumber.js >=6.0.0 -// Project: https://github.com/MikeMcl/bignumber.js -// Definitions by: Michael Mclaughlin <https://github.com/MikeMcl> -// Definitions: https://github.com/MikeMcl/bignumber.js - -// Documentation: http://mikemcl.github.io/bignumber.js/ -// -// Exports (available globally or when using import): -// -// class BigNumber (default export) -// type BigNumber.Constructor -// type BigNumber.Instance -// type BigNumber.ModuloMode -// type BigNumber.RoundingMOde -// type BigNumber.Value -// interface BigNumber.Config -// interface BigNumber.Format -// -// Example (alternative syntax commented-out): -// -// import {BigNumber} from "bignumber.js" -// //import BigNumber from "bignumber.js" -// -// let rm: BigNumber.RoundingMode = BigNumber.ROUND_UP; -// let f: BigNumber.Format = { decimalSeparator: ',' }; -// let c: BigNumber.Config = { DECIMAL_PLACES: 4, ROUNDING_MODE: rm, FORMAT: f }; -// BigNumber.config(c); -// -// let v: BigNumber.Value = '12345.6789'; -// let b: BigNumber = new BigNumber(v); -// //let b: BigNumber.Instance = new BigNumber(v); -// -// The use of compiler option `--strictNullChecks` is recommended. - - -type BigNumberConstructor = typeof BigNumber; -type BigNumberInstance = BigNumber; -type BigNumberModuloMode = BigNumberRoundingMode | 9; -type BigNumberRoundingMode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; -type BigNumberValue = string | number | BigNumber; - -/** - * See `BigNumber.config` and `BigNumber.clone`. - */ -interface BigNumberConfig { - - /** - * An integer, 0 to 1e+9. Default value: 20. - * - * The maximum number of decimal places of the result of operations involving division, i.e. - * division, square root and base conversion operations, and exponentiation when the exponent is - * negative. - * - * ```ts - * BigNumber.config({ DECIMAL_PLACES: 5 }) - * BigNumber.set({ DECIMAL_PLACES: 5 }) - * ``` - */ - DECIMAL_PLACES?: number; - - /** - * An integer, 0 to 8. Default value: `BigNumber.ROUND_HALF_UP` (4). - * - * The rounding mode used in operations that involve division (see `DECIMAL_PLACES`) and the - * default rounding mode of the `decimalPlaces`, `precision`, `toExponential`, `toFixed`, - * `toFormat` and `toPrecision` methods. - * - * The modes are available as enumerated properties of the BigNumber constructor. - * - * ```ts - * BigNumber.config({ ROUNDING_MODE: 0 }) - * BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP }) - * ``` - */ - ROUNDING_MODE?: BigNumberRoundingMode; - - /** - * An integer, 0 to 1e+9, or an array, [-1e+9 to 0, 0 to 1e+9]. - * Default value: `[-7, 20]`. - * - * 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 exponential notation is used. - * - * For example, to emulate JavaScript numbers in terms of the exponent values at which they begin - * to use exponential notation, use `[-7, 20]`. - * - * ```ts - * BigNumber.config({ EXPONENTIAL_AT: 2 }) - * new BigNumber(12.3) // '12.3' e is only 1 - * new BigNumber(123) // '1.23e+2' - * new BigNumber(0.123) // '0.123' e is only -1 - * new BigNumber(0.0123) // '1.23e-2' - * - * BigNumber.config({ EXPONENTIAL_AT: [-7, 20] }) - * new BigNumber(123456789) // '123456789' e is only 8 - * new BigNumber(0.000000123) // '1.23e-7' - * - * // Almost never return exponential notation: - * BigNumber.config({ EXPONENTIAL_AT: 1e+9 }) - * - * // Always return exponential notation: - * BigNumber.config({ EXPONENTIAL_AT: 0 }) - * ``` - * - * Regardless of the value of `EXPONENTIAL_AT`, the `toFixed` method will always return a value in - * normal notation and the `toExponential` method will always return a value in exponential form. - * Calling `toString` with a base argument, e.g. `toString(10)`, will also always return normal - * notation. - */ - EXPONENTIAL_AT?: number|[number, number]; - - /** - * An integer, magnitude 1 to 1e+9, or an array, [-1e+9 to -1, 1 to 1e+9]. - * Default value: `[-1e+9, 1e+9]`. - * - * 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. - * - * For example, to emulate JavaScript numbers in terms of the exponent values at which they - * become zero and Infinity, use [-324, 308]. - * - * ```ts - * BigNumber.config({ RANGE: 500 }) - * BigNumber.config().RANGE // [ -500, 500 ] - * new BigNumber('9.999e499') // '9.999e+499' - * new BigNumber('1e500') // 'Infinity' - * new BigNumber('1e-499') // '1e-499' - * new BigNumber('1e-500') // '0' - * - * BigNumber.config({ RANGE: [-3, 4] }) - * new BigNumber(99999) // '99999' e is only 4 - * new BigNumber(100000) // 'Infinity' e is 5 - * new BigNumber(0.001) // '0.01' e is only -3 - * new BigNumber(0.0001) // '0' e is -4 - * ``` - * The largest possible magnitude of a finite BigNumber is 9.999...e+1000000000. - * The smallest possible magnitude of a non-zero BigNumber is 1e-1000000000. - */ - RANGE?: number|[number, number]; - - /** - * A boolean: `true` or `false`. Default value: `false`. - * - * 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 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). - * - * See `BigNumber.random`. - * - * ```ts - * BigNumber.config({ CRYPTO: true }) - * BigNumber.config().CRYPTO // true - * BigNumber.random() // 0.54340758610486147524 - * ``` - */ - CRYPTO?: boolean; - - /** - * An integer, 0 to 9. Default value: `BigNumber.ROUND_DOWN` (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`. - * - * The modes that are most commonly used for the modulus/remainder operation are shown in the - * following table. Although the other rounding modes can be used, they may not give useful - * results. - * - * Property | Value | Description - * :------------------|:------|:------------------------------------------------------------------ - * `ROUND_UP` | 0 | The remainder is positive if the dividend is negative. - * `ROUND_DOWN` | 1 | The remainder has the same sign as the dividend. - * | | Uses 'truncating division' and matches JavaScript's `%` operator . - * `ROUND_FLOOR` | 3 | The remainder has the same sign as the divisor. - * | | This matches Python's `%` operator. - * `ROUND_HALF_EVEN` | 6 | The IEEE 754 remainder function. - * `EUCLID` | 9 | The remainder is always positive. - * | | Euclidian division: `q = sign(n) * floor(a / abs(n))` - * - * The rounding/modulo modes are available as enumerated properties of the BigNumber constructor. - * - * See `modulo`. - * - * ```ts - * BigNumber.config({ MODULO_MODE: BigNumber.EUCLID }) - * BigNumber.set({ MODULO_MODE: 9 }) // equivalent - * ``` - */ - MODULO_MODE?: BigNumberModuloMode; - - /** - * An integer, 0 to 1e+9. Default value: 0. - * - * The maximum precision, i.e. number of significant digits, of the result of the power operation - * - unless a modulus is specified. - * - * If set to 0, the number of significant digits will not be limited. - * - * See `exponentiatedBy`. - * - * ```ts - * BigNumber.config({ POW_PRECISION: 100 }) - * ``` - */ - POW_PRECISION?: number; - - /** - * An object including any number of the properties shown below. - * - * The object configures the format of the string returned by the `toFormat` method. - * The example below shows the properties of the object that are recognised, and - * their default values. - * - * Unlike the other configuration properties, the values of the properties of the `FORMAT` object - * will not be checked for validity - the existing object will simply be replaced by the object - * that is passed in. - * - * See `toFormat`. - * - * ```ts - * BigNumber.config({ - * FORMAT: { - * // the decimal separator - * decimalSeparator: '.', - * // the grouping separator of the integer part - * groupSeparator: ',', - * // the primary grouping size of the integer part - * groupSize: 3, - * // the secondary grouping size of the integer part - * secondaryGroupSize: 0, - * // the grouping separator of the fraction part - * fractionGroupSeparator: ' ', - * // the grouping size of the fraction part - * fractionGroupSize: 0 - * } - * }) - * ``` - */ - FORMAT?: BigNumberFormat; - - /** - * A string representing the alphabet used for base conversion. - * Default value: `'0123456789abcdefghijklmnopqrstuvwxyz'`. - * - * The length of the alphabet corresponds to the maximum value of the base argument that can be - * passed to the BigNumber constructor or `toString`. There is no maximum length, but it must be - * at least 2 characters long, and it must not contain a repeated character, or `'.'` - the - * decimal separator for all values whatever their base. - * - * ```ts - * // duodecimal (base 12) - * BigNumber.config({ ALPHABET: '0123456789TE' }) - * x = new BigNumber('T', 12) - * x.toString() // '10' - * x.toString(12) // 'T' - * ``` - */ - ALPHABET?: string; -} - - -/** - * See `FORMAT` and `toFormat`. - */ -interface BigNumberFormat { - - /** - * 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; -} - - -export declare class BigNumber { - - /** - * Used internally by the `BigNumber.isBigNumber` method. - */ - private readonly _isBigNumber: true; - - /** - * The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers. - */ - readonly c: number[]; - - /** - * The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000. - */ - readonly e: number; - - /** - * The sign of the value of this BigNumber, -1 or 1. - */ - readonly s: number; - - /** - * Returns a new instance of BigNumber with value `n`. - * - * Legitimate values for `n` include ±0, ±`Infinity` and `NaN`. - * - * Values of type number with more than 15 significant digits are considered invalid as calling - * `toString` or `valueOf` on such numbers may not result in the intended value. - * - * ```ts - * console.log( 823456789123456.3 ); // 823456789123456.2 - * ``` - * - * There is no limit to the number of digits of a value of type string (other than that of - * JavaScript's maximum array size). Decimal string values may be in exponential, as well as - * normal (fixed-point) notation. Non-decimal values must be in normal notation. - * - * String values in hexadecimal literal form, e.g. '0xff', are valid, as are string values with - * the octal and binary prefixs '0o' and '0b'. String values in octal literal form without the - * prefix will be interpreted as decimals, e.g. '011' is interpreted as 11, not 9. - * - * Values in any base may have fraction digits. - * - * If a base is specified, `n` is rounded according to the current `DECIMAL_PLACES` and - * `ROUNDING_MODE` settings. If base is omitted, or is `null` or `undefined`, base 10 is assumed. - * - * Throws an invalid `value` or `base`. - * - * ```ts - * x = new BigNumber(9) // '9' - * y = new BigNumber(x) // '9' - * - * // 'new' is optional - * BigNumber(435.345) // '435.345' - * - * new BigNumber('5032485723458348569331745.33434346346912144534543') - * new BigNumber('4.321e+4') // '43210' - * new BigNumber('-735.0918e-430') // '-7.350918e-428' - * new BigNumber(Infinity) // 'Infinity' - * new BigNumber(NaN) // 'NaN' - * new BigNumber('.5') // '0.5' - * new BigNumber('+2') // '2' - * new BigNumber(-10110100.1, 2) // '-180.5' - * new BigNumber(-0b10110100.1) // '-180.5' - * new BigNumber('123412421.234324', 5) // '607236.557696' - * new BigNumber('ff.8', 16) // '255.5' - * new BigNumber('0xff.8') // '255.5' - * - * // The following throws 'Not a base 2 number'. - * new BigNumber(9, 2) - * - * // The following throws 'Number primitive has more than 15 significant digits'. - * new BigNumber(96517860459076817.4395) - * - * // The following throws 'Not a number'. - * new BigNumber('blurgh') - * - * // A value is only rounded by the constructor if a base is specified. - * BigNumber.config({ DECIMAL_PLACES: 5 }) - * new BigNumber(1.23456789) // '1.23456789' - * new BigNumber(1.23456789, 10) // '1.23457' - * ``` - * - * @param n A numeric value. - * @param base The base of n, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`). - */ - constructor(n: BigNumberValue, base?: number); - - /** - * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this - * BigNumber. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber(-0.8) - * x.absoluteValue() // '0.8' - * ``` - */ - absoluteValue(): BigNumber; - - /** - * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this - * BigNumber. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber(-0.8) - * x.abs() // '0.8' - * ``` - */ - abs(): 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` - * - * ```ts - * - * x = new BigNumber(Infinity) - * y = new BigNumber(5) - * x.comparedTo(y) // 1 - * x.comparedTo(x.minus(1)) // 0 - * y.comparedTo(NaN) // null - * y.comparedTo('110', 2) // -1 - * ``` - * @param n A numeric value. - * @param [base] The base of n. - */ - comparedTo(n: BigNumberValue, base?: number): number; - - /** - * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode - * `roundingMode` to a maximum of `decimalPlaces` decimal places. - * - * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of - * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is - * ±`Infinity` or `NaN`. - * - * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `decimalPlaces` or `roundingMode` is invalid. - * - * ```ts - * x = new BigNumber(1234.56) - * x.decimalPlaces() // 2 - * x.decimalPlaces(1) // '1234.6' - * x.decimalPlaces(2) // '1234.56' - * x.decimalPlaces(10) // '1234.56' - * x.decimalPlaces(0, 1) // '1234' - * x.decimalPlaces(0, 6) // '1235' - * x.decimalPlaces(1, 1) // '1234.5' - * x.decimalPlaces(1, BigNumber.ROUND_HALF_EVEN) // '1234.6' - * x // '1234.56' - * y = new BigNumber('9.9e-101') - * y.decimalPlaces() // 102 - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - decimalPlaces(decimalPlaces?: number, roundingMode?: BigNumberRoundingMode): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode - * `roundingMode` to a maximum of `decimalPlaces` decimal places. - * - * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of - * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is - * ±`Infinity` or `NaN`. - * - * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `decimalPlaces` or `roundingMode` is invalid. - * - * ```ts - * x = new BigNumber(1234.56) - * x.dp() // 2 - * x.dp(1) // '1234.6' - * x.dp(2) // '1234.56' - * x.dp(10) // '1234.56' - * x.dp(0, 1) // '1234' - * x.dp(0, 6) // '1235' - * x.dp(1, 1) // '1234.5' - * x.dp(1, BigNumber.ROUND_HALF_EVEN) // '1234.6' - * x // '1234.56' - * y = new BigNumber('9.9e-101') - * y.dp() // 102 - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - dp(decimalPlaces?: number, roundingMode?: BigNumberRoundingMode): 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` settings. - * - * ```ts - * x = new BigNumber(355) - * y = new BigNumber(113) - * x.dividedBy(y) // '3.14159292035398230088' - * x.dividedBy(5) // '71' - * x.dividedBy(47, 16) // '5' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - dividedBy(n: BigNumberValue, 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` settings. - * - * ```ts - * x = new BigNumber(355) - * y = new BigNumber(113) - * x.div(y) // '3.14159292035398230088' - * x.div(5) // '71' - * x.div(47, 16) // '5' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - div(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by - * `n`. - * - * ```ts - * x = new BigNumber(5) - * y = new BigNumber(3) - * x.dividedToIntegerBy(y) // '1' - * x.dividedToIntegerBy(0.7) // '7' - * x.dividedToIntegerBy('0.f', 16) // '5' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - dividedToIntegerBy(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by - * `n`. - * - * ```ts - * x = new BigNumber(5) - * y = new BigNumber(3) - * x.idiv(y) // '1' - * x.idiv(0.7) // '7' - * x.idiv('0.f', 16) // '5' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - idiv(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e. - * 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` settings. - * - * As the number of digits of the result of the power operation can grow so large so quickly, - * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is - * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified). - * - * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant - * digits will be calculated, and that the method's performance will decrease dramatically for - * larger exponents. - * - * If `m` is specified and the value of `m`, `n` and this BigNumber are positive integers, then a - * fast modular exponentiation algorithm is used, otherwise if any of the values is not a positive - * integer the operation will simply be performed as `x.exponentiatedBy(n).modulo(m)` with a - * `POW_PRECISION` of 0. - * - * Throws if `n` is not a primitive number, or is not an integer, or is out of range. - * - * ```ts - * Math.pow(0.7, 2) // 0.48999999999999994 - * x = new BigNumber(0.7) - * x.exponentiatedBy(2) // '0.49' - * BigNumber(3).exponentiatedBy(-2) // '0.11111111111111111111' - * ``` - * - * @param n The exponent, an integer, -9007199254740991 to 9007199254740991. - * @param [m] The modulus, a positive integer. - */ - exponentiatedBy(n: number, m?: BigNumberValue): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e. - * 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` settings. - * - * As the number of digits of the result of the power operation can grow so large so quickly, - * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is - * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified). - * - * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant - * digits will be calculated, and that the method's performance will decrease dramatically for - * larger exponents. - * - * If `m` is specified and the value of `m`, `n` and this BigNumber are positive integers, then a - * fast modular exponentiation algorithm is used, otherwise if any of the values is not a positive - * integer the operation will simply be performed as `x.exponentiatedBy(n).modulo(m)` with a - * `POW_PRECISION` of 0. - * - * Throws if `n` is not a primitive number or an integer, or is out of range. - * - * ```ts - * Math.pow(0.7, 2) // 0.48999999999999994 - * x = new BigNumber(0.7) - * x.pow(2) // '0.49' - * BigNumber(3).pow(-2) // '0.11111111111111111111' - * ``` - * - * @param n The exponent, an integer, -9007199254740991 to 9007199254740991. - * @param [m] The modulus, a positive integer. - */ - pow(n: number, m?: BigNumberValue): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using - * rounding mode `rm`. - * - * If `rm` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `rm` is invalid. - * - * ```ts - * x = new BigNumber(123.456) - * x.integerValue() // '123' - * x.integerValue(BigNumber.ROUND_CEIL) // '124' - * y = new BigNumber(-12.7) - * y.integerValue() // '-13' - * x.integerValue(BigNumber.ROUND_DOWN) // '-12' - * ``` - * - * @param {BigNumberRoundingMode} [rm] The roundng mode, an integer, 0 to 8. - */ - integerValue(rm?: BigNumberRoundingMode): BigNumber; - - /** - * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns - * `false`. - * - * As with JavaScript, `NaN` does not equal `NaN`. - * - * ```ts - * 0 === 1e-324 // true - * x = new BigNumber(0) - * x.isEqualTo('1e-324') // false - * BigNumber(-0).isEqualTo(x) // true ( -0 === 0 ) - * BigNumber(255).isEqualTo('ff', 16) // true - * - * y = new BigNumber(NaN) - * y.isEqualTo(NaN) // false - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - isEqualTo(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns - * `false`. - * - * As with JavaScript, `NaN` does not equal `NaN`. - * - * ```ts - * 0 === 1e-324 // true - * x = new BigNumber(0) - * x.eq('1e-324') // false - * BigNumber(-0).eq(x) // true ( -0 === 0 ) - * BigNumber(255).eq('ff', 16) // true - * - * y = new BigNumber(NaN) - * y.eq(NaN) // false - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - eq(n: BigNumberValue, 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`. - * - * ```ts - * x = new BigNumber(1) - * x.isFinite() // true - * y = new BigNumber(Infinity) - * y.isFinite() // false - * ``` - */ - isFinite(): boolean; - - /** - * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise - * returns `false`. - * - * ```ts - * 0.1 > (0.3 - 0.2) // true - * x = new BigNumber(0.1) - * x.isGreaterThan(BigNumber(0.3).minus(0.2)) // false - * BigNumber(0).isGreaterThan(x) // false - * BigNumber(11, 3).isGreaterThan(11.1, 2) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - isGreaterThan(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise - * returns `false`. - * - * ```ts - * 0.1 > (0.3 - 0 // true - * x = new BigNumber(0.1) - * x.gt(BigNumber(0.3).minus(0.2)) // false - * BigNumber(0).gt(x) // false - * BigNumber(11, 3).gt(11.1, 2) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - gt(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`, - * otherwise returns `false`. - * - * ```ts - * (0.3 - 0.2) >= 0.1 // false - * x = new BigNumber(0.3).minus(0.2) - * x.isGreaterThanOrEqualTo(0.1) // true - * BigNumber(1).isGreaterThanOrEqualTo(x) // true - * BigNumber(10, 18).isGreaterThanOrEqualTo('i', 36) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - isGreaterThanOrEqualTo(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`, - * otherwise returns `false`. - * - * ```ts - * (0.3 - 0.2) >= 0.1 // false - * x = new BigNumber(0.3).minus(0.2) - * x.gte(0.1) // true - * BigNumber(1).gte(x) // true - * BigNumber(10, 18).gte('i', 36) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - gte(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is an integer, otherwise returns `false`. - * - * ```ts - * x = new BigNumber(1) - * x.isInteger() // true - * y = new BigNumber(123.456) - * y.isInteger() // false - * ``` - */ - isInteger(): boolean; - - /** - * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns - * `false`. - * - * ```ts - * (0.3 - 0.2) < 0.1 // true - * x = new BigNumber(0.3).minus(0.2) - * x.isLessThan(0.1) // false - * BigNumber(0).isLessThan(x) // true - * BigNumber(11.1, 2).isLessThan(11, 3) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - isLessThan(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns - * `false`. - * - * ```ts - * (0.3 - 0.2) < 0.1 // true - * x = new BigNumber(0.3).minus(0.2) - * x.lt(0.1) // false - * BigNumber(0).lt(x) // true - * BigNumber(11.1, 2).lt(11, 3) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - lt(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`, - * otherwise returns `false`. - * - * ```ts - * 0.1 <= (0.3 - 0.2) // false - * x = new BigNumber(0.1) - * x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2)) // true - * BigNumber(-1).isLessThanOrEqualTo(x) // true - * BigNumber(10, 18).isLessThanOrEqualTo('i', 36) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - isLessThanOrEqualTo(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`, - * otherwise returns `false`. - * - * ```ts - * 0.1 <= (0.3 - 0.2) // false - * x = new BigNumber(0.1) - * x.lte(BigNumber(0.3).minus(0.2)) // true - * BigNumber(-1).lte(x) // true - * BigNumber(10, 18).lte('i', 36) // true - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - lte(n: BigNumberValue, base?: number): boolean; - - /** - * Returns `true` if the value of this BigNumber is `NaN`, otherwise returns `false`. - * - * ```ts - * x = new BigNumber(NaN) - * x.isNaN() // true - * y = new BigNumber('Infinity') - * y.isNaN() // false - * ``` - */ - isNaN(): boolean; - - /** - * Returns `true` if the value of this BigNumber is negative, otherwise returns `false`. - * - * ```ts - * x = new BigNumber(-0) - * x.isNegative() // true - * y = new BigNumber(2) - * y.isNegative() // false - * ``` - */ - isNegative(): boolean; - - /** - * Returns `true` if the value of this BigNumber is positive, otherwise returns `false`. - * - * ```ts - * x = new BigNumber(-0) - * x.isPositive() // false - * y = new BigNumber(2) - * y.isPositive() // true - * ``` - */ - isPositive(): boolean; - - /** - * Returns `true` if the value of this BigNumber is zero or minus zero, otherwise returns `false`. - * - * ```ts - * x = new BigNumber(-0) - * x.isZero() // true - * ``` - */ - isZero(): boolean; - - /** - * Returns a BigNumber whose value is the value of this BigNumber minus `n`. - * - * The return value is always exact and unrounded. - * - * ```ts - * 0.3 - 0.1 // 0.19999999999999998 - * x = new BigNumber(0.3) - * x.minus(0.1) // '0.2' - * x.minus(0.6, 20) // '0' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - minus(n: BigNumberValue, 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. - * - * The return value is always exact and unrounded. - * - * See `MODULO_MODE` for a description of the other modulo modes. - * - * ```ts - * 1 % 0.9 // 0.09999999999999998 - * x = new BigNumber(1) - * x.modulo(0.9) // '0.1' - * y = new BigNumber(33) - * y.modulo('a', 33) // '3' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - modulo(n: BigNumberValue, 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. - * - * The return value is always exact and unrounded. - * - * See `MODULO_MODE` for a description of the other modulo modes. - * - * ```ts - * 1 % 0.9 // 0.09999999999999998 - * x = new BigNumber(1) - * x.mod(0.9) // '0.1' - * y = new BigNumber(33) - * y.mod('a', 33) // '3' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - mod(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`. - * - * The return value is always exact and unrounded. - * - * ```ts - * 0.6 * 3 // 1.7999999999999998 - * x = new BigNumber(0.6) - * y = x.multipliedBy(3) // '1.8' - * BigNumber('7e+500').multipliedBy(y) // '1.26e+501' - * x.multipliedBy('-a', 16) // '-6' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - multipliedBy(n: BigNumberValue, base?: number) : BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`. - * - * The return value is always exact and unrounded. - * - * ```ts - * 0.6 * 3 // 1.7999999999999998 - * x = new BigNumber(0.6) - * y = x.times(3) // '1.8' - * BigNumber('7e+500').times(y) // '1.26e+501' - * x.times('-a', 16) // '-6' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - times(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by -1. - * - * ```ts - * x = new BigNumber(1.8) - * x.negated() // '-1.8' - * y = new BigNumber(-1.3) - * y.negated() // '1.3' - * ``` - */ - negated(): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber plus `n`. - * - * The return value is always exact and unrounded. - * - * ```ts - * 0.1 + 0.2 // 0.30000000000000004 - * x = new BigNumber(0.1) - * y = x.plus(0.2) // '0.3' - * BigNumber(0.7).plus(x).plus(y) // '1' - * x.plus('0.1', 8) // '0.225' - * ``` - * - * @param n A numeric value. - * @param [base] The base of n. - */ - plus(n: BigNumberValue, base?: number): BigNumber; - - /** - * Returns the number of significant digits of the value of this BigNumber, or `null` if the value - * of this BigNumber is ±`Infinity` or `NaN`. - * - * If `includeZeros` is true then any trailing zeros of the integer part of the value of this - * BigNumber are counted as significant digits, otherwise they are not. - * - * Throws if `includeZeros` is invalid. - * - * ```ts - * x = new BigNumber(9876.54321) - * x.precision() // 9 - * y = new BigNumber(987000) - * y.precision(false) // 3 - * y.precision(true) // 6 - * ``` - * - * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count. - */ - precision(includeZeros?: boolean): number; - - /** - * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of - * `significantDigits` significant digits using rounding mode `roundingMode`. - * - * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used. - * - * Throws if `significantDigits` or `roundingMode` is invalid. - * - * ```ts - * x = new BigNumber(9876.54321) - * x.precision(6) // '9876.54' - * x.precision(6, BigNumber.ROUND_UP) // '9876.55' - * x.precision(2) // '9900' - * x.precision(2, 1) // '9800' - * x // '9876.54321' - * ``` - * - * @param significantDigits Significant digits, integer, 1 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - precision(significantDigits: number, roundingMode?: BigNumberRoundingMode): BigNumber; - - /** - * Returns the number of significant digits of the value of this BigNumber, - * or `null` if the value of this BigNumber is ±`Infinity` or `NaN`. - * - * If `includeZeros` is true then any trailing zeros of the integer part of - * the value of this BigNumber are counted as significant digits, otherwise - * they are not. - * - * Throws if `includeZeros` is invalid. - * - * ```ts - * x = new BigNumber(9876.54321) - * x.sd() // 9 - * y = new BigNumber(987000) - * y.sd(false) // 3 - * y.sd(true) // 6 - * ``` - * - * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count. - */ - sd(includeZeros?: boolean): number; - - /* - * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of - * `significantDigits` significant digits using rounding mode `roundingMode`. - * - * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used. - * - * Throws if `significantDigits` or `roundingMode` is invalid. - * - * ```ts - * x = new BigNumber(9876.54321) - * x.sd(6) // '9876.54' - * x.sd(6, BigNumber.ROUND_UP) // '9876.55' - * x.sd(2) // '9900' - * x.sd(2, 1) // '9800' - * x // '9876.54321' - * ``` - * - * @param significantDigits Significant digits, integer, 1 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - sd(significantDigits: number, roundingMode?: BigNumberRoundingMode): BigNumber; - - /** - * Returns a BigNumber whose value is the value of this BigNumber shifted by `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. - * - * The return value is always exact and unrounded. - * - * Throws if `n` is invalid. - * - * ```ts - * x = new BigNumber(1.23) - * x.shiftedBy(3) // '1230' - * x.shiftedBy(-3) // '0.00123' - * ``` - * - * @param n The shift value, integer, -9007199254740991 to 9007199254740991. - */ - shiftedBy(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` settings. - * - * 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. - * - * ```ts - * x = new BigNumber(16) - * x.squareRoot() // '4' - * y = new BigNumber(3) - * y.squareRoot() // '1.73205080756887729353' - * ``` - */ - 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` settings. - * - * 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. - * - * ```ts - * x = new BigNumber(16) - * x.sqrt() // '4' - * y = new BigNumber(3) - * y.sqrt() // '1.73205080756887729353' - * ``` - */ - sqrt(): BigNumber; - - /** - * Returns a string representing the value of this BigNumber in exponential notation rounded using - * rounding mode `roundingMode` to `decimalPlaces` decimal places, i.e with one digit before the - * decimal point and `decimalPlaces` digits after it. - * - * If the value of this BigNumber in exponential notation has fewer than `decimalPlaces` fraction - * digits, the return value will be appended with zeros accordingly. - * - * If `decimalPlaces` 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 `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `decimalPlaces` or `roundingMode` is invalid. - * - * ```ts - * x = 45.6 - * y = new BigNumber(x) - * x.toExponential() // '4.56e+1' - * y.toExponential() // '4.56e+1' - * x.toExponential(0) // '5e+1' - * y.toExponential(0) // '5e+1' - * x.toExponential(1) // '4.6e+1' - * y.toExponential(1) // '4.6e+1' - * y.toExponential(1, 1) // '4.5e+1' (ROUND_DOWN) - * x.toExponential(3) // '4.560e+1' - * y.toExponential(3) // '4.560e+1' - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - toExponential(decimalPlaces?: number, roundingMode?: BigNumberRoundingMode): string; - - /** - * Returns a string representing the value of this BigNumber in normal (fixed-point) notation - * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`. - * - * If the value of this BigNumber in normal notation has fewer than `decimalPlaces` 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 10**21, this method will always return normal notation. - * - * If `decimalPlaces` 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 normal notation is required and the current - * `EXPONENTIAL_AT` setting causes `toString` to return exponential notation. - * - * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `decimalPlaces` or `roundingMode` is invalid. - * - * ```ts - * x = 3.456 - * y = new BigNumber(x) - * x.toFixed() // '3' - * y.toFixed() // '3.456' - * y.toFixed(0) // '3' - * x.toFixed(2) // '3.46' - * y.toFixed(2) // '3.46' - * y.toFixed(2, 1) // '3.45' (ROUND_DOWN) - * x.toFixed(5) // '3.45600' - * y.toFixed(5) // '3.45600' - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - toFixed(decimalPlaces?: number, roundingMode?: BigNumberRoundingMode): string; - - /** - * Returns a string representing the value of this BigNumber in normal (fixed-point) notation - * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`, and formatted - * according to the properties of the `FORMAT` object. - * - * The properties of the `FORMAT` object are shown in the examples below. - * - * If `decimalPlaces` is omitted or is `null` or `undefined`, then the return value is not - * rounded to a fixed number of decimal places. - * - * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `decimalPlaces` or `roundingMode` is invalid. - * - * ```ts - * format = { - * decimalSeparator: '.', - * groupSeparator: ',', - * groupSize: 3, - * secondaryGroupSize: 0, - * fractionGroupSeparator: ' ', - * fractionGroupSize: 0 - * } - * BigNumber.config({ FORMAT: format }) - * - * x = new BigNumber('123456789.123456789') - * x.toFormat() // '123,456,789.123456789' - * x.toFormat(1) // '123,456,789.1' - * - * format.groupSeparator = ' ' - * format.fractionGroupSize = 5 - * x.toFormat() // '123 456 789.12345 6789' - * - * BigNumber.config({ - * FORMAT: { - * decimalSeparator: ',', - * groupSeparator: '.', - * groupSize: 3, - * secondaryGroupSize: 2 - * } - * }) - * - * x.toFormat(6) // '12.34.56.789,123' - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - * @param [roundingMode] Rounding mode, integer, 0 to 8. - */ - toFormat(decimalPlaces?: number, roundingMode?: BigNumberRoundingMode): 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_denominator`. - * - * If a maximum denominator, `max_denominator`, is not specified, or is `null` or `undefined`, the - * denominator will be the lowest value necessary to represent the number exactly. - * - * Throws if `max_denominator` is invalid. - * - * ```ts - * x = new BigNumber(1.75) - * x.toFraction() // '7, 4' - * - * pi = new BigNumber('3.14159265358') - * pi.toFraction() // '157079632679,50000000000' - * pi.toFraction(100000) // '312689, 99532' - * pi.toFraction(10000) // '355, 113' - * pi.toFraction(100) // '311, 99' - * pi.toFraction(10) // '22, 7' - * pi.toFraction(1) // '3, 1' - * ``` - * - * @param [max_denominator] The maximum denominator, integer, >= 1 and < Infinity. - */ - toFraction(max_denominator?: BigNumberValue): BigNumber[]; - - /** - * As `valueOf`. - */ - toJSON(): string; - - /** - * Returns the value of this BigNumber as a JavaScript primitive number. - * - * Using the unary plus operator gives the same result. - * - * ```ts - * x = new BigNumber(456.789) - * x.toNumber() // 456.789 - * +x // 456.789 - * - * y = new BigNumber('45987349857634085409857349856430985') - * y.toNumber() // 4.598734985763409e+34 - * - * z = new BigNumber(-0) - * 1 / z.toNumber() // -Infinity - * 1 / +z // -Infinity - * ``` - */ - toNumber(): number; - - /** - * Returns a string representing the value of this BigNumber rounded to `significantDigits` - * significant digits using rounding mode `roundingMode`. - * - * If `significantDigits` 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 `significantDigits` is omitted, or is `null` or `undefined`, then the return value is the - * same as `n.toString()`. - * - * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used. - * - * Throws if `significantDigits` or `roundingMode` is invalid. - * - * ```ts - * x = 45.6 - * y = new BigNumber(x) - * x.toPrecision() // '45.6' - * y.toPrecision() // '45.6' - * x.toPrecision(1) // '5e+1' - * y.toPrecision(1) // '5e+1' - * y.toPrecision(2, 0) // '4.6e+1' (ROUND_UP) - * y.toPrecision(2, 1) // '4.5e+1' (ROUND_DOWN) - * x.toPrecision(5) // '45.600' - * y.toPrecision(5) // '45.600' - * ``` - * - * @param [significantDigits] Significant digits, integer, 1 to 1e+9. - * @param [roundingMode] Rounding mode, integer 0 to 8. - */ - toPrecision(significantDigits?: number, roundingMode?: BigNumberRoundingMode): string; - - /** - * Returns a string representing the value of this BigNumber in base `base`, or base 10 if `base` - * is omitted or is `null` or `undefined`. - * - * For bases above 10, and using the default base conversion alphabet (see `ALPHABET`), values - * from 10 to 35 are represented by a-z (the same as `Number.prototype.toString`). - * - * If a base is specified the value is rounded according to the current `DECIMAL_PLACES` and - * `ROUNDING_MODE` settings, otherwise it is not. - * - * If a base is not specified, and this BigNumber has a positive exponent that is equal to or - * greater than the positive component of the current `EXPONENTIAL_AT` setting, or a negative - * exponent equal to or less than the negative component of the setting, then exponential notation - * is returned. - * - * If `base` is `null` or `undefined` it is ignored. - * - * Throws if `base` is invalid. - * - * ```ts - * x = new BigNumber(750000) - * x.toString() // '750000' - * BigNumber.config({ EXPONENTIAL_AT: 5 }) - * x.toString() // '7.5e+5' - * - * y = new BigNumber(362.875) - * y.toString(2) // '101101010.111' - * y.toString(9) // '442.77777777777777777778' - * y.toString(32) // 'ba.s' - * - * BigNumber.config({ DECIMAL_PLACES: 4 }); - * z = new BigNumber('1.23456789') - * z.toString() // '1.23456789' - * z.toString(10) // '1.2346' - * ``` - * - * @param [base] The base, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`). - */ - toString(base?: number): string; - - /** - * As `toString`, but does not accept a base argument and includes the minus sign for negative - * zero. - * - * ``ts - * x = new BigNumber('-0') - * x.toString() // '0' - * x.valueOf() // '-0' - * y = new BigNumber('1.777e+457') - * y.valueOf() // '1.777e+457' - * ``` - */ - valueOf(): string; - - /** - * Returns a new independent BigNumber constructor with configuration as described by `object`, or - * with the default configuration if object is `null` or `undefined`. - * - * Throws if `object` is not an object. - * - * ```ts - * BigNumber.config({ DECIMAL_PLACES: 5 }) - * BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) - * - * x = new BigNumber(1) - * y = new BN(1) - * - * x.div(3) // 0.33333 - * y.div(3) // 0.333333333 - * - * // BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) is equivalent to: - * BN = BigNumber.clone() - * BN.config({ DECIMAL_PLACES: 9 }) - * ``` - * - * @param [object] The configuration object. - */ - static clone(object?: BigNumberConfig): BigNumberConstructor; - - /** - * Configures the settings that apply to this BigNumber constructor. - * - * The configuration object, `object`, contains any number of the properties shown in the example - * below. - * - * Returns an object with the above properties and their current values. - * - * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the - * properties. - * - * ```ts - * BigNumber.config({ - * DECIMAL_PLACES: 40, - * ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL, - * EXPONENTIAL_AT: [-10, 20], - * RANGE: [-500, 500], - * CRYPTO: true, - * MODULO_MODE: BigNumber.ROUND_FLOOR, - * POW_PRECISION: 80, - * FORMAT: { - * groupSize: 3, - * groupSeparator: ' ', - * decimalSeparator: ',' - * }, - * ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_' - * }); - * - * BigNumber.config().DECIMAL_PLACES // 40 - * ``` - * - * @param object The configuration object. - */ - static config(object: BigNumberConfig): BigNumberConfig; - - /** - * Returns `true` if `value` is a BigNumber instance, otherwise returns `false`. - * - * ```ts - * x = 42 - * y = new BigNumber(x) - * - * BigNumber.isBigNumber(x) // false - * y instanceof BigNumber // true - * BigNumber.isBigNumber(y) // true - * - * BN = BigNumber.clone(); - * z = new BN(x) - * z instanceof BigNumber // false - * BigNumber.isBigNumber(z) // true - * ``` - * - * @param value The value to test. - */ - static isBigNumber(value: any): boolean; - - /** - * - * Returns a BigNumber whose value is the maximum of the arguments. - * - * Accepts either an argument list or an array of values. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber('3257869345.0378653') - * BigNumber.maximum(4e9, x, '123456789.9') // '4000000000' - * - * arr = [12, '13', new BigNumber(14)] - * BigNumber.maximum(arr) // '14' - * ``` - * - * @param n A numeric value. - */ - static maximum(...n: BigNumberValue[]): BigNumber; - - /** - * Returns a BigNumber whose value is the maximum of the arguments. - * - * Accepts either an argument list or an array of values. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber('3257869345.0378653') - * BigNumber.max(4e9, x, '123456789.9') // '4000000000' - * - * arr = [12, '13', new BigNumber(14)] - * BigNumber.max(arr) // '14' - * ``` - * - * @param n A numeric value. - */ - static max(...n: BigNumberValue[]): BigNumber; - - /** - * Returns a BigNumber whose value is the minimum of the arguments. - * - * Accepts either an argument list or an array of values. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber('3257869345.0378653') - * BigNumber.minimum(4e9, x, '123456789.9') // '123456789.9' - * - * arr = [2, new BigNumber(-14), '-15.9999', -12] - * BigNumber.minimum(arr) // '-15.9999' - * ``` - * - * @param n A numeric value. - */ - static minimum(...n: BigNumberValue[]): BigNumber; - - /** - * Returns a BigNumber whose value is the minimum of the arguments. - * - * Accepts either an argument list or an array of values. - * - * The return value is always exact and unrounded. - * - * ```ts - * x = new BigNumber('3257869345.0378653') - * BigNumber.min(4e9, x, '123456789.9') // '123456789.9' - * - * arr = [2, new BigNumber(-14), '-15.9999', -12] - * BigNumber.min(arr) // '-15.9999' - * ``` - * - * @param n A numeric value. - */ - static min(...n: BigNumberValue[]): 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 `decimalPlaces` decimal places, or less if trailing zeros are - * produced. If `decimalPlaces` is omitted, the current `DECIMAL_PLACES` setting will be used. - * - * 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. - * - * Throws if `decimalPlaces` is invalid. - * - * ```ts - * BigNumber.config({ DECIMAL_PLACES: 10 }) - * BigNumber.random() // '0.4117936847' - * BigNumber.random(20) // '0.78193327636914089009' - * ``` - * - * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9. - */ - static random(decimalPlaces?: number): BigNumber; - - /** - * Configures the settings that apply to this BigNumber constructor. - * - * The configuration object, `object`, contains any number of the properties shown in the example - * below. - * - * Returns an object with the above properties and their current values. - * - * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the - * properties. - * - * ```ts - * BigNumber.set({ - * DECIMAL_PLACES: 40, - * ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL, - * EXPONENTIAL_AT: [-10, 20], - * RANGE: [-500, 500], - * CRYPTO: true, - * MODULO_MODE: BigNumber.ROUND_FLOOR, - * POW_PRECISION: 80, - * FORMAT: { - * groupSize: 3, - * groupSeparator: ' ', - * decimalSeparator: ',' - * }, - * ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_' - * }); - * - * BigNumber.set().DECIMAL_PLACES // 40 - * ``` - * - * @param object The configuration object. - */ - static set(object: BigNumberConfig): BigNumberConfig; - - /** - * Helps ES6 import. - */ - private static readonly default?: BigNumberConstructor; - - /** - * Helps ES6 import. - */ - private static readonly BigNumber?: BigNumberConstructor; - - /** - * Rounds away from zero. - */ - static readonly ROUND_UP: 0; - - /** - * Rounds towards zero. - */ - static readonly ROUND_DOWN: 1; - - /** - * Rounds towards Infinity. - */ - static readonly ROUND_CEIL: 2; - - /** - * Rounds towards -Infinity. - */ - static readonly ROUND_FLOOR: 3; - - /** - * Rounds towards nearest neighbour. If equidistant, rounds away from zero . - */ - static readonly ROUND_HALF_UP: 4; - - /** - * Rounds towards nearest neighbour. If equidistant, rounds towards zero. - */ - static readonly ROUND_HALF_DOWN: 5; - - /** - * Rounds towards nearest neighbour. If equidistant, rounds towards even neighbour. - */ - static readonly ROUND_HALF_EVEN: 6; - - /** - * Rounds towards nearest neighbour. If equidistant, rounds towards Infinity. - */ - static readonly ROUND_HALF_CEIL: 7; - - /** - * Rounds towards nearest neighbour. If equidistant, rounds towards -Infinity. - */ - static readonly ROUND_HALF_FLOOR: 8; - - /** - * See `MODULO_MODE`. - */ - static readonly EUCLID: 9; -} - - -export default BigNumber; - -export namespace BigNumber { - export type Config = BigNumberConfig; - export type Constructor = BigNumberConstructor; - export type Format = BigNumberFormat; - export type Instance = BigNumberInstance; - export type ModuloMode = BigNumberModuloMode; - export type RoundingMode = BigNumberRoundingMode; - export type Value = BigNumberValue; -} - -/** - * Browsers. - */ -declare global { - const BigNumber: BigNumberConstructor; - type BigNumber = BigNumberInstance; - - namespace BigNumber { - type Config = BigNumberConfig; - type Constructor = BigNumberConstructor; - type Format = BigNumberFormat; - type Instance = BigNumberInstance; - type ModuloMode = BigNumberModuloMode; - type RoundingMode = BigNumberRoundingMode; - type Value = BigNumberValue; - } -}
\ No newline at end of file diff --git a/packages/instant/test/util/dependencies/prevbignumber.js b/packages/instant/test/util/dependencies/prevbignumber.js deleted file mode 100644 index e2d3f2146..000000000 --- a/packages/instant/test/util/dependencies/prevbignumber.js +++ /dev/null @@ -1,2705 +0,0 @@ -/* - * bignumber.js v6.0.0 - * A JavaScript library for arbitrary-precision arithmetic. - * https://github.com/MikeMcl/bignumber.js - * Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com> - * MIT Licensed. - * - * BigNumber.prototype methods | BigNumber methods - * | - * absoluteValue abs | clone - * comparedTo | config set - * decimalPlaces dp | DECIMAL_PLACES - * dividedBy div | ROUNDING_MODE - * dividedToIntegerBy idiv | EXPONENTIAL_AT - * exponentiatedBy pow | RANGE - * integerValue | CRYPTO - * isEqualTo eq | MODULO_MODE - * isFinite | POW_PRECISION - * isGreaterThan gt | FORMAT - * isGreaterThanOrEqualTo gte | ALPHABET - * isInteger | isBigNumber - * isLessThan lt | maximum max - * isLessThanOrEqualTo lte | minimum min - * isNaN | random - * isNegative | - * isPositive | - * isZero | - * minus | - * modulo mod | - * multipliedBy times | - * negated | - * plus | - * precision sd | - * shiftedBy | - * squareRoot sqrt | - * toExponential | - * toFixed | - * toFormat | - * toFraction | - * toJSON | - * toNumber | - * toPrecision | - * toString | - * valueOf | - * - */ - - -var BigNumber, - isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, - - mathceil = Math.ceil, - mathfloor = Math.floor, - - bignumberError = '[BigNumber Error] ', - tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ', - - BASE = 1e14, - LOG_BASE = 14, - MAX_SAFE_INTEGER = 0x1fffffffffffff, // 2^53 - 1 - // MAX_INT32 = 0x7fffffff, // 2^31 - 1 - POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], - SQRT_BASE = 1e7, - - // EDITABLE - // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and - // the arguments to toExponential, toFixed, toFormat, and toPrecision. - MAX = 1E9; // 0 to MAX_INT32 - - -/* - * Create and return a BigNumber constructor. - */ -function clone(configObject) { - var div, convertBase, parseNumeric, - P = BigNumber.prototype, - ONE = new BigNumber(1), - - - //----------------------------- EDITABLE CONFIG DEFAULTS ------------------------------- - - - // The default values below must be integers within the inclusive ranges stated. - // The values can also be changed at run-time using BigNumber.set. - - // The maximum number of decimal places for operations involving division. - DECIMAL_PLACES = 20, // 0 to MAX - - // The rounding mode used when rounding to the above decimal places, and when using - // toExponential, toFixed, toFormat and toPrecision, and round (default value). - // UP 0 Away from zero. - // DOWN 1 Towards zero. - // CEIL 2 Towards +Infinity. - // FLOOR 3 Towards -Infinity. - // HALF_UP 4 Towards nearest neighbour. If equidistant, up. - // HALF_DOWN 5 Towards nearest neighbour. If equidistant, down. - // HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour. - // HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity. - // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity. - ROUNDING_MODE = 4, // 0 to 8 - - // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS] - - // The exponent value at and beneath which toString returns exponential notation. - // Number type: -7 - TO_EXP_NEG = -7, // 0 to -MAX - - // The exponent value at and above which toString returns exponential notation. - // Number type: 21 - TO_EXP_POS = 21, // 0 to MAX - - // RANGE : [MIN_EXP, MAX_EXP] - - // The minimum exponent value, beneath which underflow to zero occurs. - // Number type: -324 (5e-324) - MIN_EXP = -1e7, // -1 to -MAX - - // The maximum exponent value, above which overflow to Infinity occurs. - // Number type: 308 (1.7976931348623157e+308) - // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow. - MAX_EXP = 1e7, // 1 to MAX - - // Whether to use cryptographically-secure random number generation, if available. - CRYPTO = false, // true or false - - // The modulo mode used when calculating the modulus: a mod n. - // The quotient (q = a / n) is calculated according to the corresponding rounding mode. - // The remainder (r) is calculated as: r = a - n * q. - // - // UP 0 The remainder is positive if the dividend is negative, else is negative. - // DOWN 1 The remainder has the same sign as the dividend. - // This modulo mode is commonly known as 'truncated division' and is - // equivalent to (a % n) in JavaScript. - // FLOOR 3 The remainder has the same sign as the divisor (Python %). - // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function. - // EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)). - // The remainder is always positive. - // - // The truncated division, floored division, Euclidian division and IEEE 754 remainder - // modes are commonly used for the modulus operation. - // Although the other rounding modes can also be used, they may not give useful results. - MODULO_MODE = 1, // 0 to 9 - - // The maximum number of significant digits of the result of the exponentiatedBy operation. - // If POW_PRECISION is 0, there will be unlimited significant digits. - POW_PRECISION = 0, // 0 to MAX - - // The format specification used by the BigNumber.prototype.toFormat method. - FORMAT = { - decimalSeparator: '.', - groupSeparator: ',', - groupSize: 3, - secondaryGroupSize: 0, - fractionGroupSeparator: '\xA0', // non-breaking space - fractionGroupSize: 0 - }, - - // The alphabet used for base conversion. - // It must be at least 2 characters long, with no '.' or repeated character. - // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_' - ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'; - - - //------------------------------------------------------------------------------------------ - - - // CONSTRUCTOR - - - /* - * The BigNumber constructor and exported function. - * Create and return a new instance of a BigNumber object. - * - * n {number|string|BigNumber} A numeric value. - * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive. - */ - function BigNumber( n, b ) { - var alphabet, c, e, i, isNum, len, str, - x = this; - - // Enable constructor usage without new. - if ( !( x instanceof BigNumber ) ) { - - // Don't throw on constructor call without new (#81). - // '[BigNumber Error] Constructor call without new: {n}' - //throw Error( bignumberError + ' Constructor call without new: ' + n ); - return new BigNumber( n, b ); - } - - if ( b == null ) { - - // Duplicate. - if ( n instanceof BigNumber ) { - x.s = n.s; - x.e = n.e; - x.c = ( n = n.c ) ? n.slice() : n; - return; - } - - isNum = typeof n == 'number'; - - if ( isNum && n * 0 == 0 ) { - - // Use `1 / n` to handle minus zero also. - x.s = 1 / n < 0 ? ( n = -n, -1 ) : 1; - - // Faster path for integers. - if ( n === ~~n ) { - for ( e = 0, i = n; i >= 10; i /= 10, e++ ); - x.e = e; - x.c = [n]; - return; - } - - str = n + ''; - } else { - if ( !isNumeric.test( str = n + '' ) ) return parseNumeric( x, str, isNum ); - x.s = str.charCodeAt(0) == 45 ? ( str = str.slice(1), -1 ) : 1; - } - - } else { - - // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}' - intCheck( b, 2, ALPHABET.length, 'Base' ); - str = n + ''; - - // Allow exponential notation to be used with base 10 argument, while - // also rounding to DECIMAL_PLACES as with other bases. - if ( b == 10 ) { - x = new BigNumber( n instanceof BigNumber ? n : str ); - return round( x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE ); - } - - isNum = typeof n == 'number'; - - if (isNum) { - - // Avoid potential interpretation of Infinity and NaN as base 44+ values. - if ( n * 0 != 0 ) return parseNumeric( x, str, isNum, b ); - - x.s = 1 / n < 0 ? ( str = str.slice(1), -1 ) : 1; - - // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}' - if ( str.replace( /^0\.0*|\./, '' ).length > 15 ) { - throw Error - ( tooManyDigits + n ); - } - - // Prevent later check for length on converted number. - isNum = false; - } else { - x.s = str.charCodeAt(0) === 45 ? ( str = str.slice(1), -1 ) : 1; - - // Allow e.g. hexadecimal 'FF' as well as 'ff'. - if ( b > 10 && b < 37 ) str = str.toLowerCase(); - } - - alphabet = ALPHABET.slice( 0, b ); - e = i = 0; - - // Check that str is a valid base b number. - // Don't use RegExp so alphabet can contain special characters. - for ( len = str.length; i < len; i++ ) { - if ( alphabet.indexOf( c = str.charAt(i) ) < 0 ) { - if ( c == '.' ) { - - // If '.' is not the first character and it has not be found before. - if ( i > e ) { - e = len; - continue; - } - } - - return parseNumeric( x, n + '', isNum, b ); - } - } - - str = convertBase( str, b, 10, x.s ); - } - - // Decimal point? - if ( ( e = str.indexOf('.') ) > -1 ) str = str.replace( '.', '' ); - - // Exponential form? - if ( ( i = str.search( /e/i ) ) > 0 ) { - - // Determine exponent. - if ( e < 0 ) e = i; - e += +str.slice( i + 1 ); - str = str.substring( 0, i ); - } else if ( e < 0 ) { - - // Integer. - e = str.length; - } - - // Determine leading zeros. - for ( i = 0; str.charCodeAt(i) === 48; i++ ); - - // Determine trailing zeros. - for ( len = str.length; str.charCodeAt(--len) === 48; ); - str = str.slice( i, len + 1 ); - - if (str) { - len = str.length; - - // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}' - if ( isNum && len > 15 && ( n > MAX_SAFE_INTEGER || n !== mathfloor(n) ) ) { - throw Error - ( tooManyDigits + ( x.s * n ) ); - } - - e = e - i - 1; - - // Overflow? - if ( e > MAX_EXP ) { - - // Infinity. - x.c = x.e = null; - - // Underflow? - } else if ( e < MIN_EXP ) { - - // Zero. - x.c = [ x.e = 0 ]; - } else { - x.e = e; - x.c = []; - - // Transform base - - // e is the base 10 exponent. - // i is where to slice str to get the first element of the coefficient array. - i = ( e + 1 ) % LOG_BASE; - if ( e < 0 ) i += LOG_BASE; - - if ( i < len ) { - if (i) x.c.push( +str.slice( 0, i ) ); - - for ( len -= LOG_BASE; i < len; ) { - x.c.push( +str.slice( i, i += LOG_BASE ) ); - } - - str = str.slice(i); - i = LOG_BASE - str.length; - } else { - i -= len; - } - - for ( ; i--; str += '0' ); - x.c.push( +str ); - } - } else { - - // Zero. - x.c = [ x.e = 0 ]; - } - } - - - // CONSTRUCTOR PROPERTIES - - - BigNumber.clone = clone; - - BigNumber.ROUND_UP = 0; - BigNumber.ROUND_DOWN = 1; - BigNumber.ROUND_CEIL = 2; - BigNumber.ROUND_FLOOR = 3; - BigNumber.ROUND_HALF_UP = 4; - BigNumber.ROUND_HALF_DOWN = 5; - BigNumber.ROUND_HALF_EVEN = 6; - BigNumber.ROUND_HALF_CEIL = 7; - BigNumber.ROUND_HALF_FLOOR = 8; - BigNumber.EUCLID = 9; - - - /* - * Configure infrequently-changing library-wide settings. - * - * Accept an object with the following optional properties (if the value of a property is - * a number, it must be an integer within the inclusive range stated): - * - * DECIMAL_PLACES {number} 0 to MAX - * ROUNDING_MODE {number} 0 to 8 - * EXPONENTIAL_AT {number|number[]} -MAX to MAX or [-MAX to 0, 0 to MAX] - * RANGE {number|number[]} -MAX to MAX (not zero) or [-MAX to -1, 1 to MAX] - * CRYPTO {boolean} true or false - * MODULO_MODE {number} 0 to 9 - * POW_PRECISION {number} 0 to MAX - * ALPHABET {string} A string of two or more unique characters, and not - * containing '.'. The empty string, null or undefined - * resets the alphabet to its default value. - * FORMAT {object} An object with some of the following properties: - * decimalSeparator {string} - * groupSeparator {string} - * groupSize {number} - * secondaryGroupSize {number} - * fractionGroupSeparator {string} - * fractionGroupSize {number} - * - * (The values assigned to the above FORMAT object properties are not checked for validity.) - * - * E.g. - * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 }) - * - * Ignore properties/parameters set to null or undefined, except for ALPHABET. - * - * Return an object with the properties current values. - */ - BigNumber.config = BigNumber.set = function (obj) { - var p, v; - - if ( obj != null ) { - - if ( typeof obj == 'object' ) { - - // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive. - // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}' - if ( obj.hasOwnProperty( p = 'DECIMAL_PLACES' ) ) { - v = obj[p]; - intCheck( v, 0, MAX, p ); - DECIMAL_PLACES = v; - } - - // ROUNDING_MODE {number} Integer, 0 to 8 inclusive. - // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}' - if ( obj.hasOwnProperty( p = 'ROUNDING_MODE' ) ) { - v = obj[p]; - intCheck( v, 0, 8, p ); - ROUNDING_MODE = v; - } - - // EXPONENTIAL_AT {number|number[]} - // Integer, -MAX to MAX inclusive or - // [integer -MAX to 0 inclusive, 0 to MAX inclusive]. - // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}' - if ( obj.hasOwnProperty( p = 'EXPONENTIAL_AT' ) ) { - v = obj[p]; - if ( isArray(v) ) { - intCheck( v[0], -MAX, 0, p ); - intCheck( v[1], 0, MAX, p ); - TO_EXP_NEG = v[0]; - TO_EXP_POS = v[1]; - } else { - intCheck( v, -MAX, MAX, p ); - TO_EXP_NEG = -( TO_EXP_POS = v < 0 ? -v : v ); - } - } - - // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or - // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive]. - // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}' - if ( obj.hasOwnProperty( p = 'RANGE' ) ) { - v = obj[p]; - if ( isArray(v) ) { - intCheck( v[0], -MAX, -1, p ); - intCheck( v[1], 1, MAX, p ); - MIN_EXP = v[0]; - MAX_EXP = v[1]; - } else { - intCheck( v, -MAX, MAX, p ); - if (v) { - MIN_EXP = -( MAX_EXP = v < 0 ? -v : v ); - } else { - throw Error - ( bignumberError + p + ' cannot be zero: ' + v ); - } - } - } - - // CRYPTO {boolean} true or false. - // '[BigNumber Error] CRYPTO not true or false: {v}' - // '[BigNumber Error] crypto unavailable' - if ( obj.hasOwnProperty( p = 'CRYPTO' ) ) { - v = obj[p]; - if ( v === !!v ) { - if (v) { - if ( typeof crypto != 'undefined' && crypto && - (crypto.getRandomValues || crypto.randomBytes) ) { - CRYPTO = v; - } else { - CRYPTO = !v; - throw Error - ( bignumberError + 'crypto unavailable' ); - } - } else { - CRYPTO = v; - } - } else { - throw Error - ( bignumberError + p + ' not true or false: ' + v ); - } - } - - // MODULO_MODE {number} Integer, 0 to 9 inclusive. - // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}' - if ( obj.hasOwnProperty( p = 'MODULO_MODE' ) ) { - v = obj[p]; - intCheck( v, 0, 9, p ); - MODULO_MODE = v; - } - - // POW_PRECISION {number} Integer, 0 to MAX inclusive. - // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}' - if ( obj.hasOwnProperty( p = 'POW_PRECISION' ) ) { - v = obj[p]; - intCheck( v, 0, MAX, p ); - POW_PRECISION = v; - } - - // FORMAT {object} - // '[BigNumber Error] FORMAT not an object: {v}' - if ( obj.hasOwnProperty( p = 'FORMAT' ) ) { - v = obj[p]; - if ( typeof v == 'object' ) FORMAT = v; - else throw Error - ( bignumberError + p + ' not an object: ' + v ); - } - - // ALPHABET {string} - // '[BigNumber Error] ALPHABET invalid: {v}' - if ( obj.hasOwnProperty( p = 'ALPHABET' ) ) { - v = obj[p]; - - // Disallow if only one character, or contains '.' or a repeated character. - if ( typeof v == 'string' && !/^.$|\.|(.).*\1/.test(v) ) { - ALPHABET = v; - } else { - throw Error - ( bignumberError + p + ' invalid: ' + v ); - } - } - - } else { - - // '[BigNumber Error] Object expected: {v}' - throw Error - ( bignumberError + 'Object expected: ' + obj ); - } - } - - return { - DECIMAL_PLACES: DECIMAL_PLACES, - ROUNDING_MODE: ROUNDING_MODE, - EXPONENTIAL_AT: [ TO_EXP_NEG, TO_EXP_POS ], - RANGE: [ MIN_EXP, MAX_EXP ], - CRYPTO: CRYPTO, - MODULO_MODE: MODULO_MODE, - POW_PRECISION: POW_PRECISION, - FORMAT: FORMAT, - ALPHABET: ALPHABET - }; - }; - - - /* - * Return true if v is a BigNumber instance, otherwise return false. - * - * v {any} - */ - BigNumber.isBigNumber = function (v) { - return v instanceof BigNumber || v && v._isBigNumber === true || false; - }; - - - /* - * Return a new BigNumber whose value is the maximum of the arguments. - * - * arguments {number|string|BigNumber} - */ - BigNumber.maximum = BigNumber.max = function () { - return maxOrMin( arguments, P.lt ); - }; - - - /* - * Return a new BigNumber whose value is the minimum of the arguments. - * - * arguments {number|string|BigNumber} - */ - BigNumber.minimum = BigNumber.min = function () { - return maxOrMin( arguments, P.gt ); - }; - - - /* - * Return a new BigNumber with a random value equal to or greater than 0 and less than 1, - * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing - * zeros are produced). - * - * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}' - * '[BigNumber Error] crypto unavailable' - */ - BigNumber.random = (function () { - var pow2_53 = 0x20000000000000; - - // Return a 53 bit integer n, where 0 <= n < 9007199254740992. - // Check if Math.random() produces more than 32 bits of randomness. - // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits. - // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1. - var random53bitInt = (Math.random() * pow2_53) & 0x1fffff - ? function () { return mathfloor( Math.random() * pow2_53 ); } - : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) + - (Math.random() * 0x800000 | 0); }; - - return function (dp) { - var a, b, e, k, v, - i = 0, - c = [], - rand = new BigNumber(ONE); - - if ( dp == null ) dp = DECIMAL_PLACES; - else intCheck( dp, 0, MAX ); - - k = mathceil( dp / LOG_BASE ); - - if (CRYPTO) { - - // Browsers supporting crypto.getRandomValues. - if (crypto.getRandomValues) { - - a = crypto.getRandomValues( new Uint32Array( k *= 2 ) ); - - for ( ; i < k; ) { - - // 53 bits: - // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2) - // 11111 11111111 11111111 11111111 11100000 00000000 00000000 - // ((Math.pow(2, 32) - 1) >>> 11).toString(2) - // 11111 11111111 11111111 - // 0x20000 is 2^21. - v = a[i] * 0x20000 + (a[i + 1] >>> 11); - - // Rejection sampling: - // 0 <= v < 9007199254740992 - // Probability that v >= 9e15, is - // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251 - if ( v >= 9e15 ) { - b = crypto.getRandomValues( new Uint32Array(2) ); - a[i] = b[0]; - a[i + 1] = b[1]; - } else { - - // 0 <= v <= 8999999999999999 - // 0 <= (v % 1e14) <= 99999999999999 - c.push( v % 1e14 ); - i += 2; - } - } - i = k / 2; - - // Node.js supporting crypto.randomBytes. - } else if (crypto.randomBytes) { - - // buffer - a = crypto.randomBytes( k *= 7 ); - - for ( ; i < k; ) { - - // 0x1000000000000 is 2^48, 0x10000000000 is 2^40 - // 0x100000000 is 2^32, 0x1000000 is 2^24 - // 11111 11111111 11111111 11111111 11111111 11111111 11111111 - // 0 <= v < 9007199254740992 - v = ( ( a[i] & 31 ) * 0x1000000000000 ) + ( a[i + 1] * 0x10000000000 ) + - ( a[i + 2] * 0x100000000 ) + ( a[i + 3] * 0x1000000 ) + - ( a[i + 4] << 16 ) + ( a[i + 5] << 8 ) + a[i + 6]; - - if ( v >= 9e15 ) { - crypto.randomBytes(7).copy( a, i ); - } else { - - // 0 <= (v % 1e14) <= 99999999999999 - c.push( v % 1e14 ); - i += 7; - } - } - i = k / 7; - } else { - CRYPTO = false; - throw Error - ( bignumberError + 'crypto unavailable' ); - } - } - - // Use Math.random. - if (!CRYPTO) { - - for ( ; i < k; ) { - v = random53bitInt(); - if ( v < 9e15 ) c[i++] = v % 1e14; - } - } - - k = c[--i]; - dp %= LOG_BASE; - - // Convert trailing digits to zeros according to dp. - if ( k && dp ) { - v = POWS_TEN[LOG_BASE - dp]; - c[i] = mathfloor( k / v ) * v; - } - - // Remove trailing elements which are zero. - for ( ; c[i] === 0; c.pop(), i-- ); - - // Zero? - if ( i < 0 ) { - c = [ e = 0 ]; - } else { - - // Remove leading elements which are zero and adjust exponent accordingly. - for ( e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE); - - // Count the digits of the first element of c to determine leading zeros, and... - for ( i = 1, v = c[0]; v >= 10; v /= 10, i++); - - // adjust the exponent accordingly. - if ( i < LOG_BASE ) e -= LOG_BASE - i; - } - - rand.e = e; - rand.c = c; - return rand; - }; - })(); - - - // PRIVATE FUNCTIONS - - - // Called by BigNumber and BigNumber.prototype.toString. - convertBase = ( function () { - var decimal = '0123456789'; - - /* - * Convert string of baseIn to an array of numbers of baseOut. - * Eg. toBaseOut('255', 10, 16) returns [15, 15]. - * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5]. - */ - function toBaseOut( str, baseIn, baseOut, alphabet ) { - var j, - arr = [0], - arrL, - i = 0, - len = str.length; - - for ( ; i < len; ) { - for ( arrL = arr.length; arrL--; arr[arrL] *= baseIn ); - - arr[0] += alphabet.indexOf( str.charAt( i++ ) ); - - for ( j = 0; j < arr.length; j++ ) { - - if ( arr[j] > baseOut - 1 ) { - if ( arr[j + 1] == null ) arr[j + 1] = 0; - arr[j + 1] += arr[j] / baseOut | 0; - arr[j] %= baseOut; - } - } - } - - return arr.reverse(); - } - - // Convert a numeric string of baseIn to a numeric string of baseOut. - // If the caller is toString, we are converting from base 10 to baseOut. - // If the caller is BigNumber, we are converting from baseIn to base 10. - return function ( str, baseIn, baseOut, sign, callerIsToString ) { - var alphabet, d, e, k, r, x, xc, y, - i = str.indexOf( '.' ), - dp = DECIMAL_PLACES, - rm = ROUNDING_MODE; - - // Non-integer. - if ( i >= 0 ) { - k = POW_PRECISION; - - // Unlimited precision. - POW_PRECISION = 0; - str = str.replace( '.', '' ); - y = new BigNumber(baseIn); - x = y.pow( str.length - i ); - POW_PRECISION = k; - - // Convert str as if an integer, then restore the fraction part by dividing the - // result by its base raised to a power. - - y.c = toBaseOut( toFixedPoint( coeffToString( x.c ), x.e, '0' ), - 10, baseOut, decimal ); - y.e = y.c.length; - } - - // Convert the number as integer. - - xc = toBaseOut( str, baseIn, baseOut, callerIsToString - ? ( alphabet = ALPHABET, decimal ) - : ( alphabet = decimal, ALPHABET ) ); - - - // xc now represents str as an integer and converted to baseOut. e is the exponent. - e = k = xc.length; - - // Remove trailing zeros. - for ( ; xc[--k] == 0; xc.pop() ); - - // Zero? - if ( !xc[0] ) return alphabet.charAt(0); - - // Does str represent an integer? If so, no need for the division. - if ( i < 0 ) { - --e; - } else { - x.c = xc; - x.e = e; - - // The sign is needed for correct rounding. - x.s = sign; - x = div( x, y, dp, rm, baseOut ); - xc = x.c; - r = x.r; - e = x.e; - } - - // xc now represents str converted to baseOut. - - // THe index of the rounding digit. - d = e + dp + 1; - - // The rounding digit: the digit to the right of the digit that may be rounded up. - i = xc[d]; - - // Look at the rounding digits and mode to determine whether to round up. - - k = baseOut / 2; - r = r || d < 0 || xc[d + 1] != null; - - r = rm < 4 ? ( i != null || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) ) - : i > k || i == k &&( rm == 4 || r || rm == 6 && xc[d - 1] & 1 || - rm == ( x.s < 0 ? 8 : 7 ) ); - - // If the index of the rounding digit is not greater than zero, or xc represents - // zero, then the result of the base conversion is zero or, if rounding up, a value - // such as 0.00001. - if ( d < 1 || !xc[0] ) { - - // 1^-dp or 0 - str = r ? toFixedPoint( alphabet.charAt(1), -dp, alphabet.charAt(0) ) - : alphabet.charAt(0); - } else { - - // Truncate xc to the required number of decimal places. - xc.length = d; - - // Round up? - if (r) { - - // Rounding up may mean the previous digit has to be rounded up and so on. - for ( --baseOut; ++xc[--d] > baseOut; ) { - xc[d] = 0; - - if ( !d ) { - ++e; - xc = [1].concat(xc); - } - } - } - - // Determine trailing zeros. - for ( k = xc.length; !xc[--k]; ); - - // E.g. [4, 11, 15] becomes 4bf. - for ( i = 0, str = ''; i <= k; str += alphabet.charAt( xc[i++] ) ); - - // Add leading zeros, decimal point and trailing zeros as required. - str = toFixedPoint( str, e, alphabet.charAt(0) ); - } - - // The caller will add the sign. - return str; - }; - })(); - - - // Perform division in the specified base. Called by div and convertBase. - div = (function () { - - // Assume non-zero x and k. - function multiply( x, k, base ) { - var m, temp, xlo, xhi, - carry = 0, - i = x.length, - klo = k % SQRT_BASE, - khi = k / SQRT_BASE | 0; - - for ( x = x.slice(); i--; ) { - xlo = x[i] % SQRT_BASE; - xhi = x[i] / SQRT_BASE | 0; - m = khi * xlo + xhi * klo; - temp = klo * xlo + ( ( m % SQRT_BASE ) * SQRT_BASE ) + carry; - carry = ( temp / base | 0 ) + ( m / SQRT_BASE | 0 ) + khi * xhi; - x[i] = temp % base; - } - - if (carry) x = [carry].concat(x); - - return x; - } - - function compare( a, b, aL, bL ) { - var i, cmp; - - if ( aL != bL ) { - cmp = aL > bL ? 1 : -1; - } else { - - for ( i = cmp = 0; i < aL; i++ ) { - - if ( a[i] != b[i] ) { - cmp = a[i] > b[i] ? 1 : -1; - break; - } - } - } - return cmp; - } - - function subtract( a, b, aL, base ) { - var i = 0; - - // Subtract b from a. - for ( ; aL--; ) { - a[aL] -= i; - i = a[aL] < b[aL] ? 1 : 0; - a[aL] = i * base + a[aL] - b[aL]; - } - - // Remove leading zeros. - for ( ; !a[0] && a.length > 1; a.splice(0, 1) ); - } - - // x: dividend, y: divisor. - return function ( x, y, dp, rm, base ) { - var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, - yL, yz, - s = x.s == y.s ? 1 : -1, - xc = x.c, - yc = y.c; - - // Either NaN, Infinity or 0? - if ( !xc || !xc[0] || !yc || !yc[0] ) { - - return new BigNumber( - - // Return NaN if either NaN, or both Infinity or 0. - !x.s || !y.s || ( xc ? yc && xc[0] == yc[0] : !yc ) ? NaN : - - // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0. - xc && xc[0] == 0 || !yc ? s * 0 : s / 0 - ); - } - - q = new BigNumber(s); - qc = q.c = []; - e = x.e - y.e; - s = dp + e + 1; - - if ( !base ) { - base = BASE; - e = bitFloor( x.e / LOG_BASE ) - bitFloor( y.e / LOG_BASE ); - s = s / LOG_BASE | 0; - } - - // Result exponent may be one less then the current value of e. - // The coefficients of the BigNumbers from convertBase may have trailing zeros. - for ( i = 0; yc[i] == ( xc[i] || 0 ); i++ ); - - if ( yc[i] > ( xc[i] || 0 ) ) e--; - - if ( s < 0 ) { - qc.push(1); - more = true; - } else { - xL = xc.length; - yL = yc.length; - i = 0; - s += 2; - - // Normalise xc and yc so highest order digit of yc is >= base / 2. - - n = mathfloor( base / ( yc[0] + 1 ) ); - - // Not necessary, but to handle odd bases where yc[0] == ( base / 2 ) - 1. - // if ( n > 1 || n++ == 1 && yc[0] < base / 2 ) { - if ( n > 1 ) { - yc = multiply( yc, n, base ); - xc = multiply( xc, n, base ); - yL = yc.length; - xL = xc.length; - } - - xi = yL; - rem = xc.slice( 0, yL ); - remL = rem.length; - - // Add zeros to make remainder as long as divisor. - for ( ; remL < yL; rem[remL++] = 0 ); - yz = yc.slice(); - yz = [0].concat(yz); - yc0 = yc[0]; - if ( yc[1] >= base / 2 ) yc0++; - // Not necessary, but to prevent trial digit n > base, when using base 3. - // else if ( base == 3 && yc0 == 1 ) yc0 = 1 + 1e-15; - - do { - n = 0; - - // Compare divisor and remainder. - cmp = compare( yc, rem, yL, remL ); - - // If divisor < remainder. - if ( cmp < 0 ) { - - // Calculate trial digit, n. - - rem0 = rem[0]; - if ( yL != remL ) rem0 = rem0 * base + ( rem[1] || 0 ); - - // n is how many times the divisor goes into the current remainder. - n = mathfloor( rem0 / yc0 ); - - // Algorithm: - // 1. product = divisor * trial digit (n) - // 2. if product > remainder: product -= divisor, n-- - // 3. remainder -= product - // 4. if product was < remainder at 2: - // 5. compare new remainder and divisor - // 6. If remainder > divisor: remainder -= divisor, n++ - - if ( n > 1 ) { - - // n may be > base only when base is 3. - if (n >= base) n = base - 1; - - // product = divisor * trial digit. - prod = multiply( yc, n, base ); - prodL = prod.length; - remL = rem.length; - - // Compare product and remainder. - // If product > remainder. - // Trial digit n too high. - // n is 1 too high about 5% of the time, and is not known to have - // ever been more than 1 too high. - while ( compare( prod, rem, prodL, remL ) == 1 ) { - n--; - - // Subtract divisor from product. - subtract( prod, yL < prodL ? yz : yc, prodL, base ); - prodL = prod.length; - cmp = 1; - } - } else { - - // n is 0 or 1, cmp is -1. - // If n is 0, there is no need to compare yc and rem again below, - // so change cmp to 1 to avoid it. - // If n is 1, leave cmp as -1, so yc and rem are compared again. - if ( n == 0 ) { - - // divisor < remainder, so n must be at least 1. - cmp = n = 1; - } - - // product = divisor - prod = yc.slice(); - prodL = prod.length; - } - - if ( prodL < remL ) prod = [0].concat(prod); - - // Subtract product from remainder. - subtract( rem, prod, remL, base ); - remL = rem.length; - - // If product was < remainder. - if ( cmp == -1 ) { - - // Compare divisor and new remainder. - // If divisor < new remainder, subtract divisor from remainder. - // Trial digit n too low. - // n is 1 too low about 5% of the time, and very rarely 2 too low. - while ( compare( yc, rem, yL, remL ) < 1 ) { - n++; - - // Subtract divisor from remainder. - subtract( rem, yL < remL ? yz : yc, remL, base ); - remL = rem.length; - } - } - } else if ( cmp === 0 ) { - n++; - rem = [0]; - } // else cmp === 1 and n will be 0 - - // Add the next digit, n, to the result array. - qc[i++] = n; - - // Update the remainder. - if ( rem[0] ) { - rem[remL++] = xc[xi] || 0; - } else { - rem = [ xc[xi] ]; - remL = 1; - } - } while ( ( xi++ < xL || rem[0] != null ) && s-- ); - - more = rem[0] != null; - - // Leading zero? - if ( !qc[0] ) qc.splice(0, 1); - } - - if ( base == BASE ) { - - // To calculate q.e, first get the number of digits of qc[0]. - for ( i = 1, s = qc[0]; s >= 10; s /= 10, i++ ); - - round( q, dp + ( q.e = i + e * LOG_BASE - 1 ) + 1, rm, more ); - - // Caller is convertBase. - } else { - q.e = e; - q.r = +more; - } - - return q; - }; - })(); - - - /* - * Return a string representing the value of BigNumber n in fixed-point or exponential - * notation rounded to the specified decimal places or significant digits. - * - * n: a BigNumber. - * i: the index of the last digit required (i.e. the digit that may be rounded up). - * rm: the rounding mode. - * id: 1 (toExponential) or 2 (toPrecision). - */ - function format( n, i, rm, id ) { - var c0, e, ne, len, str; - - if ( rm == null ) rm = ROUNDING_MODE; - else intCheck( rm, 0, 8 ); - - if ( !n.c ) return n.toString(); - - c0 = n.c[0]; - ne = n.e; - - if ( i == null ) { - str = coeffToString( n.c ); - str = id == 1 || id == 2 && ne <= TO_EXP_NEG - ? toExponential( str, ne ) - : toFixedPoint( str, ne, '0' ); - } else { - n = round( new BigNumber(n), i, rm ); - - // n.e may have changed if the value was rounded up. - e = n.e; - - str = coeffToString( n.c ); - len = str.length; - - // toPrecision returns exponential notation if the number of significant digits - // specified is less than the number of digits necessary to represent the integer - // part of the value in fixed-point notation. - - // Exponential notation. - if ( id == 1 || id == 2 && ( i <= e || e <= TO_EXP_NEG ) ) { - - // Append zeros? - for ( ; len < i; str += '0', len++ ); - str = toExponential( str, e ); - - // Fixed-point notation. - } else { - i -= ne; - str = toFixedPoint( str, e, '0' ); - - // Append zeros? - if ( e + 1 > len ) { - if ( --i > 0 ) for ( str += '.'; i--; str += '0' ); - } else { - i += e - len; - if ( i > 0 ) { - if ( e + 1 == len ) str += '.'; - for ( ; i--; str += '0' ); - } - } - } - } - - return n.s < 0 && c0 ? '-' + str : str; - } - - - // Handle BigNumber.max and BigNumber.min. - function maxOrMin( args, method ) { - var m, n, - i = 0; - - if ( isArray( args[0] ) ) args = args[0]; - m = new BigNumber( args[0] ); - - for ( ; ++i < args.length; ) { - n = new BigNumber( args[i] ); - - // If any number is NaN, return NaN. - if ( !n.s ) { - m = n; - break; - } else if ( method.call( m, n ) ) { - m = n; - } - } - - return m; - } - - - /* - * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP. - * Called by minus, plus and times. - */ - function normalise( n, c, e ) { - var i = 1, - j = c.length; - - // Remove trailing zeros. - for ( ; !c[--j]; c.pop() ); - - // Calculate the base 10 exponent. First get the number of digits of c[0]. - for ( j = c[0]; j >= 10; j /= 10, i++ ); - - // Overflow? - if ( ( e = i + e * LOG_BASE - 1 ) > MAX_EXP ) { - - // Infinity. - n.c = n.e = null; - - // Underflow? - } else if ( e < MIN_EXP ) { - - // Zero. - n.c = [ n.e = 0 ]; - } else { - n.e = e; - n.c = c; - } - - return n; - } - - - // Handle values that fail the validity test in BigNumber. - parseNumeric = (function () { - var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, - dotAfter = /^([^.]+)\.$/, - dotBefore = /^\.([^.]+)$/, - isInfinityOrNaN = /^-?(Infinity|NaN)$/, - whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g; - - return function ( x, str, isNum, b ) { - var base, - s = isNum ? str : str.replace( whitespaceOrPlus, '' ); - - // No exception on ±Infinity or NaN. - if ( isInfinityOrNaN.test(s) ) { - x.s = isNaN(s) ? null : s < 0 ? -1 : 1; - x.c = x.e = null; - } else { - if ( !isNum ) { - - // basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i - s = s.replace( basePrefix, function ( m, p1, p2 ) { - base = ( p2 = p2.toLowerCase() ) == 'x' ? 16 : p2 == 'b' ? 2 : 8; - return !b || b == base ? p1 : m; - }); - - if (b) { - base = b; - - // E.g. '1.' to '1', '.1' to '0.1' - s = s.replace( dotAfter, '$1' ).replace( dotBefore, '0.$1' ); - } - - if ( str != s ) return new BigNumber( s, base ); - } - - // '[BigNumber Error] Not a number: {n}' - // '[BigNumber Error] Not a base {b} number: {n}' - throw Error - ( bignumberError + 'Not a' + ( b ? ' base ' + b : '' ) + ' number: ' + str ); - } - } - })(); - - - /* - * Round x to sd significant digits using rounding mode rm. Check for over/under-flow. - * If r is truthy, it is known that there are more digits after the rounding digit. - */ - function round( x, sd, rm, r ) { - var d, i, j, k, n, ni, rd, - xc = x.c, - pows10 = POWS_TEN; - - // if x is not Infinity or NaN... - if (xc) { - - // rd is the rounding digit, i.e. the digit after the digit that may be rounded up. - // n is a base 1e14 number, the value of the element of array x.c containing rd. - // ni is the index of n within x.c. - // d is the number of digits of n. - // i is the index of rd within n including leading zeros. - // j is the actual index of rd within n (if < 0, rd is a leading zero). - out: { - - // Get the number of digits of the first element of xc. - for ( d = 1, k = xc[0]; k >= 10; k /= 10, d++ ); - i = sd - d; - - // If the rounding digit is in the first element of xc... - if ( i < 0 ) { - i += LOG_BASE; - j = sd; - n = xc[ ni = 0 ]; - - // Get the rounding digit at index j of n. - rd = n / pows10[ d - j - 1 ] % 10 | 0; - } else { - ni = mathceil( ( i + 1 ) / LOG_BASE ); - - if ( ni >= xc.length ) { - - if (r) { - - // Needed by sqrt. - for ( ; xc.length <= ni; xc.push(0) ); - n = rd = 0; - d = 1; - i %= LOG_BASE; - j = i - LOG_BASE + 1; - } else { - break out; - } - } else { - n = k = xc[ni]; - - // Get the number of digits of n. - for ( d = 1; k >= 10; k /= 10, d++ ); - - // Get the index of rd within n. - i %= LOG_BASE; - - // Get the index of rd within n, adjusted for leading zeros. - // The number of leading zeros of n is given by LOG_BASE - d. - j = i - LOG_BASE + d; - - // Get the rounding digit at index j of n. - rd = j < 0 ? 0 : n / pows10[ d - j - 1 ] % 10 | 0; - } - } - - r = r || sd < 0 || - - // Are there any non-zero digits after the rounding digit? - // The expression n % pows10[ d - j - 1 ] returns all digits of n to the right - // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714. - xc[ni + 1] != null || ( j < 0 ? n : n % pows10[ d - j - 1 ] ); - - r = rm < 4 - ? ( rd || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) ) - : rd > 5 || rd == 5 && ( rm == 4 || r || rm == 6 && - - // Check whether the digit to the left of the rounding digit is odd. - ( ( i > 0 ? j > 0 ? n / pows10[ d - j ] : 0 : xc[ni - 1] ) % 10 ) & 1 || - rm == ( x.s < 0 ? 8 : 7 ) ); - - if ( sd < 1 || !xc[0] ) { - xc.length = 0; - - if (r) { - - // Convert sd to decimal places. - sd -= x.e + 1; - - // 1, 0.1, 0.01, 0.001, 0.0001 etc. - xc[0] = pows10[ ( LOG_BASE - sd % LOG_BASE ) % LOG_BASE ]; - x.e = -sd || 0; - } else { - - // Zero. - xc[0] = x.e = 0; - } - - return x; - } - - // Remove excess digits. - if ( i == 0 ) { - xc.length = ni; - k = 1; - ni--; - } else { - xc.length = ni + 1; - k = pows10[ LOG_BASE - i ]; - - // E.g. 56700 becomes 56000 if 7 is the rounding digit. - // j > 0 means i > number of leading zeros of n. - xc[ni] = j > 0 ? mathfloor( n / pows10[ d - j ] % pows10[j] ) * k : 0; - } - - // Round up? - if (r) { - - for ( ; ; ) { - - // If the digit to be rounded up is in the first element of xc... - if ( ni == 0 ) { - - // i will be the length of xc[0] before k is added. - for ( i = 1, j = xc[0]; j >= 10; j /= 10, i++ ); - j = xc[0] += k; - for ( k = 1; j >= 10; j /= 10, k++ ); - - // if i != k the length has increased. - if ( i != k ) { - x.e++; - if ( xc[0] == BASE ) xc[0] = 1; - } - - break; - } else { - xc[ni] += k; - if ( xc[ni] != BASE ) break; - xc[ni--] = 0; - k = 1; - } - } - } - - // Remove trailing zeros. - for ( i = xc.length; xc[--i] === 0; xc.pop() ); - } - - // Overflow? Infinity. - if ( x.e > MAX_EXP ) { - x.c = x.e = null; - - // Underflow? Zero. - } else if ( x.e < MIN_EXP ) { - x.c = [ x.e = 0 ]; - } - } - - return x; - } - - - // PROTOTYPE/INSTANCE METHODS - - - /* - * Return a new BigNumber whose value is the absolute value of this BigNumber. - */ - P.absoluteValue = P.abs = function () { - var x = new BigNumber(this); - if ( x.s < 0 ) x.s = 1; - return x; - }; - - - /* - * Return - * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b), - * -1 if the value of this BigNumber is less than the value of BigNumber(y, b), - * 0 if they have the same value, - * or null if the value of either is NaN. - */ - P.comparedTo = function ( y, b ) { - return compare( this, new BigNumber( y, b ) ); - }; - - - /* - * If dp is undefined or null or true or false, return the number of decimal places of the - * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN. - * - * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this - * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or - * ROUNDING_MODE if rm is omitted. - * - * [dp] {number} Decimal places: integer, 0 to MAX inclusive. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}' - */ - P.decimalPlaces = P.dp = function ( dp, rm ) { - var c, n, v, - x = this; - - if ( dp != null ) { - intCheck( dp, 0, MAX ); - if ( rm == null ) rm = ROUNDING_MODE; - else intCheck( rm, 0, 8 ); - - return round( new BigNumber(x), dp + x.e + 1, rm ); - } - - if ( !( c = x.c ) ) return null; - n = ( ( v = c.length - 1 ) - bitFloor( this.e / LOG_BASE ) ) * LOG_BASE; - - // Subtract the number of trailing zeros of the last number. - if ( v = c[v] ) for ( ; v % 10 == 0; v /= 10, n-- ); - if ( n < 0 ) n = 0; - - return n; - }; - - - /* - * n / 0 = I - * n / N = N - * n / I = 0 - * 0 / n = 0 - * 0 / 0 = N - * 0 / N = N - * 0 / I = 0 - * N / n = N - * N / 0 = N - * N / N = N - * N / I = N - * I / n = I - * I / 0 = I - * I / N = N - * I / I = N - * - * Return a new BigNumber whose value is the value of this BigNumber divided by the value of - * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE. - */ - P.dividedBy = P.div = function ( y, b ) { - return div( this, new BigNumber( y, b ), DECIMAL_PLACES, ROUNDING_MODE ); - }; - - - /* - * Return a new BigNumber whose value is the integer part of dividing the value of this - * BigNumber by the value of BigNumber(y, b). - */ - P.dividedToIntegerBy = P.idiv = function ( y, b ) { - return div( this, new BigNumber( y, b ), 0, 1 ); - }; - - - /* - * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b), - * otherwise return false. - */ - P.isEqualTo = P.eq = function ( y, b ) { - return compare( this, new BigNumber( y, b ) ) === 0; - }; - - - /* - * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer - * using rounding mode rm, or ROUNDING_MODE if rm is omitted. - * - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}' - */ - P.integerValue = function (rm) { - var n = new BigNumber(this); - if ( rm == null ) rm = ROUNDING_MODE; - else intCheck( rm, 0, 8 ); - return round( n, n.e + 1, rm ); - }; - - - /* - * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b), - * otherwise return false. - */ - P.isGreaterThan = P.gt = function ( y, b ) { - return compare( this, new BigNumber( y, b ) ) > 0; - }; - - - /* - * Return true if the value of this BigNumber is greater than or equal to the value of - * BigNumber(y, b), otherwise return false. - */ - P.isGreaterThanOrEqualTo = P.gte = function ( y, b ) { - return ( b = compare( this, new BigNumber( y, b ) ) ) === 1 || b === 0; - - }; - - - /* - * Return true if the value of this BigNumber is a finite number, otherwise return false. - */ - P.isFinite = function () { - return !!this.c; - }; - - - /* - * Return true if the value of this BigNumber is an integer, otherwise return false. - */ - P.isInteger = function () { - return !!this.c && bitFloor( this.e / LOG_BASE ) > this.c.length - 2; - }; - - - /* - * Return true if the value of this BigNumber is NaN, otherwise return false. - */ - P.isNaN = function () { - return !this.s; - }; - - - /* - * Return true if the value of this BigNumber is negative, otherwise return false. - */ - P.isNegative = function () { - return this.s < 0; - }; - - - /* - * Return true if the value of this BigNumber is positive, otherwise return false. - */ - P.isPositive = function () { - return this.s > 0; - }; - - - /* - * Return true if the value of this BigNumber is 0 or -0, otherwise return false. - */ - P.isZero = function () { - return !!this.c && this.c[0] == 0; - }; - - - /* - * Return true if the value of this BigNumber is less than the value of BigNumber(y, b), - * otherwise return false. - */ - P.isLessThan = P.lt = function ( y, b ) { - return compare( this, new BigNumber( y, b ) ) < 0; - }; - - - /* - * Return true if the value of this BigNumber is less than or equal to the value of - * BigNumber(y, b), otherwise return false. - */ - P.isLessThanOrEqualTo = P.lte = function ( y, b ) { - return ( b = compare( this, new BigNumber( y, b ) ) ) === -1 || b === 0; - }; - - - /* - * n - 0 = n - * n - N = N - * n - I = -I - * 0 - n = -n - * 0 - 0 = 0 - * 0 - N = N - * 0 - I = -I - * N - n = N - * N - 0 = N - * N - N = N - * N - I = N - * I - n = I - * I - 0 = I - * I - N = N - * I - I = N - * - * Return a new BigNumber whose value is the value of this BigNumber minus the value of - * BigNumber(y, b). - */ - P.minus = function ( y, b ) { - var i, j, t, xLTy, - x = this, - a = x.s; - - y = new BigNumber( y, b ); - b = y.s; - - // Either NaN? - if ( !a || !b ) return new BigNumber(NaN); - - // Signs differ? - if ( a != b ) { - y.s = -b; - return x.plus(y); - } - - var xe = x.e / LOG_BASE, - ye = y.e / LOG_BASE, - xc = x.c, - yc = y.c; - - if ( !xe || !ye ) { - - // Either Infinity? - if ( !xc || !yc ) return xc ? ( y.s = -b, y ) : new BigNumber( yc ? x : NaN ); - - // Either zero? - if ( !xc[0] || !yc[0] ) { - - // Return y if y is non-zero, x if x is non-zero, or zero if both are zero. - return yc[0] ? ( y.s = -b, y ) : new BigNumber( xc[0] ? x : - - // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity - ROUNDING_MODE == 3 ? -0 : 0 ); - } - } - - xe = bitFloor(xe); - ye = bitFloor(ye); - xc = xc.slice(); - - // Determine which is the bigger number. - if ( a = xe - ye ) { - - if ( xLTy = a < 0 ) { - a = -a; - t = xc; - } else { - ye = xe; - t = yc; - } - - t.reverse(); - - // Prepend zeros to equalise exponents. - for ( b = a; b--; t.push(0) ); - t.reverse(); - } else { - - // Exponents equal. Check digit by digit. - j = ( xLTy = ( a = xc.length ) < ( b = yc.length ) ) ? a : b; - - for ( a = b = 0; b < j; b++ ) { - - if ( xc[b] != yc[b] ) { - xLTy = xc[b] < yc[b]; - break; - } - } - } - - // x < y? Point xc to the array of the bigger number. - if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s; - - b = ( j = yc.length ) - ( i = xc.length ); - - // Append zeros to xc if shorter. - // No need to add zeros to yc if shorter as subtract only needs to start at yc.length. - if ( b > 0 ) for ( ; b--; xc[i++] = 0 ); - b = BASE - 1; - - // Subtract yc from xc. - for ( ; j > a; ) { - - if ( xc[--j] < yc[j] ) { - for ( i = j; i && !xc[--i]; xc[i] = b ); - --xc[i]; - xc[j] += BASE; - } - - xc[j] -= yc[j]; - } - - // Remove leading zeros and adjust exponent accordingly. - for ( ; xc[0] == 0; xc.splice(0, 1), --ye ); - - // Zero? - if ( !xc[0] ) { - - // Following IEEE 754 (2008) 6.3, - // n - n = +0 but n - n = -0 when rounding towards -Infinity. - y.s = ROUNDING_MODE == 3 ? -1 : 1; - y.c = [ y.e = 0 ]; - return y; - } - - // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity - // for finite x and y. - return normalise( y, xc, ye ); - }; - - - /* - * n % 0 = N - * n % N = N - * n % I = n - * 0 % n = 0 - * -0 % n = -0 - * 0 % 0 = N - * 0 % N = N - * 0 % I = 0 - * N % n = N - * N % 0 = N - * N % N = N - * N % I = N - * I % n = N - * I % 0 = N - * I % N = N - * I % I = N - * - * Return a new BigNumber whose value is the value of this BigNumber modulo the value of - * BigNumber(y, b). The result depends on the value of MODULO_MODE. - */ - P.modulo = P.mod = function ( y, b ) { - var q, s, - x = this; - - y = new BigNumber( y, b ); - - // Return NaN if x is Infinity or NaN, or y is NaN or zero. - if ( !x.c || !y.s || y.c && !y.c[0] ) { - return new BigNumber(NaN); - - // Return x if y is Infinity or x is zero. - } else if ( !y.c || x.c && !x.c[0] ) { - return new BigNumber(x); - } - - if ( MODULO_MODE == 9 ) { - - // Euclidian division: q = sign(y) * floor(x / abs(y)) - // r = x - qy where 0 <= r < abs(y) - s = y.s; - y.s = 1; - q = div( x, y, 0, 3 ); - y.s = s; - q.s *= s; - } else { - q = div( x, y, 0, MODULO_MODE ); - } - - return x.minus( q.times(y) ); - }; - - - /* - * n * 0 = 0 - * n * N = N - * n * I = I - * 0 * n = 0 - * 0 * 0 = 0 - * 0 * N = N - * 0 * I = N - * N * n = N - * N * 0 = N - * N * N = N - * N * I = N - * I * n = I - * I * 0 = N - * I * N = N - * I * I = I - * - * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value - * of BigNumber(y, b). - */ - P.multipliedBy = P.times = function ( y, b ) { - var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, - base, sqrtBase, - x = this, - xc = x.c, - yc = ( y = new BigNumber( y, b ) ).c; - - // Either NaN, ±Infinity or ±0? - if ( !xc || !yc || !xc[0] || !yc[0] ) { - - // Return NaN if either is NaN, or one is 0 and the other is Infinity. - if ( !x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc ) { - y.c = y.e = y.s = null; - } else { - y.s *= x.s; - - // Return ±Infinity if either is ±Infinity. - if ( !xc || !yc ) { - y.c = y.e = null; - - // Return ±0 if either is ±0. - } else { - y.c = [0]; - y.e = 0; - } - } - - return y; - } - - e = bitFloor( x.e / LOG_BASE ) + bitFloor( y.e / LOG_BASE ); - y.s *= x.s; - xcL = xc.length; - ycL = yc.length; - - // Ensure xc points to longer array and xcL to its length. - if ( xcL < ycL ) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i; - - // Initialise the result array with zeros. - for ( i = xcL + ycL, zc = []; i--; zc.push(0) ); - - base = BASE; - sqrtBase = SQRT_BASE; - - for ( i = ycL; --i >= 0; ) { - c = 0; - ylo = yc[i] % sqrtBase; - yhi = yc[i] / sqrtBase | 0; - - for ( k = xcL, j = i + k; j > i; ) { - xlo = xc[--k] % sqrtBase; - xhi = xc[k] / sqrtBase | 0; - m = yhi * xlo + xhi * ylo; - xlo = ylo * xlo + ( ( m % sqrtBase ) * sqrtBase ) + zc[j] + c; - c = ( xlo / base | 0 ) + ( m / sqrtBase | 0 ) + yhi * xhi; - zc[j--] = xlo % base; - } - - zc[j] = c; - } - - if (c) { - ++e; - } else { - zc.splice(0, 1); - } - - return normalise( y, zc, e ); - }; - - - /* - * Return a new BigNumber whose value is the value of this BigNumber negated, - * i.e. multiplied by -1. - */ - P.negated = function () { - var x = new BigNumber(this); - x.s = -x.s || null; - return x; - }; - - - /* - * n + 0 = n - * n + N = N - * n + I = I - * 0 + n = n - * 0 + 0 = 0 - * 0 + N = N - * 0 + I = I - * N + n = N - * N + 0 = N - * N + N = N - * N + I = N - * I + n = I - * I + 0 = I - * I + N = N - * I + I = I - * - * Return a new BigNumber whose value is the value of this BigNumber plus the value of - * BigNumber(y, b). - */ - P.plus = function ( y, b ) { - var t, - x = this, - a = x.s; - - y = new BigNumber( y, b ); - b = y.s; - - // Either NaN? - if ( !a || !b ) return new BigNumber(NaN); - - // Signs differ? - if ( a != b ) { - y.s = -b; - return x.minus(y); - } - - var xe = x.e / LOG_BASE, - ye = y.e / LOG_BASE, - xc = x.c, - yc = y.c; - - if ( !xe || !ye ) { - - // Return ±Infinity if either ±Infinity. - if ( !xc || !yc ) return new BigNumber( a / 0 ); - - // Either zero? - // Return y if y is non-zero, x if x is non-zero, or zero if both are zero. - if ( !xc[0] || !yc[0] ) return yc[0] ? y : new BigNumber( xc[0] ? x : a * 0 ); - } - - xe = bitFloor(xe); - ye = bitFloor(ye); - xc = xc.slice(); - - // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts. - if ( a = xe - ye ) { - if ( a > 0 ) { - ye = xe; - t = yc; - } else { - a = -a; - t = xc; - } - - t.reverse(); - for ( ; a--; t.push(0) ); - t.reverse(); - } - - a = xc.length; - b = yc.length; - - // Point xc to the longer array, and b to the shorter length. - if ( a - b < 0 ) t = yc, yc = xc, xc = t, b = a; - - // Only start adding at yc.length - 1 as the further digits of xc can be ignored. - for ( a = 0; b; ) { - a = ( xc[--b] = xc[b] + yc[b] + a ) / BASE | 0; - xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE; - } - - if (a) { - xc = [a].concat(xc); - ++ye; - } - - // No need to check for zero, as +x + +y != 0 && -x + -y != 0 - // ye = MAX_EXP + 1 possible - return normalise( y, xc, ye ); - }; - - - /* - * If sd is undefined or null or true or false, return the number of significant digits of - * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN. - * If sd is true include integer-part trailing zeros in the count. - * - * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this - * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or - * ROUNDING_MODE if rm is omitted. - * - * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive. - * boolean: whether to count integer-part trailing zeros: true or false. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}' - */ - P.precision = P.sd = function ( sd, rm ) { - var c, n, v, - x = this; - - if ( sd != null && sd !== !!sd ) { - intCheck( sd, 1, MAX ); - if ( rm == null ) rm = ROUNDING_MODE; - else intCheck( rm, 0, 8 ); - - return round( new BigNumber(x), sd, rm ); - } - - if ( !( c = x.c ) ) return null; - v = c.length - 1; - n = v * LOG_BASE + 1; - - if ( v = c[v] ) { - - // Subtract the number of trailing zeros of the last element. - for ( ; v % 10 == 0; v /= 10, n-- ); - - // Add the number of digits of the first element. - for ( v = c[0]; v >= 10; v /= 10, n++ ); - } - - if ( sd && x.e + 1 > n ) n = x.e + 1; - - return n; - }; - - - /* - * Return a new BigNumber whose value is the value of this BigNumber shifted by k places - * (powers of 10). Shift to the right if n > 0, and to the left if n < 0. - * - * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}' - */ - P.shiftedBy = function (k) { - intCheck( k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER ); - return this.times( '1e' + k ); - }; - - - /* - * sqrt(-n) = N - * sqrt( N) = N - * sqrt(-I) = N - * sqrt( I) = I - * sqrt( 0) = 0 - * sqrt(-0) = -0 - * - * Return a new BigNumber whose value is the square root of the value of this BigNumber, - * rounded according to DECIMAL_PLACES and ROUNDING_MODE. - */ - P.squareRoot = P.sqrt = function () { - var m, n, r, rep, t, - x = this, - c = x.c, - s = x.s, - e = x.e, - dp = DECIMAL_PLACES + 4, - half = new BigNumber('0.5'); - - // Negative/NaN/Infinity/zero? - if ( s !== 1 || !c || !c[0] ) { - return new BigNumber( !s || s < 0 && ( !c || c[0] ) ? NaN : c ? x : 1 / 0 ); - } - - // Initial estimate. - s = Math.sqrt( +x ); - - // Math.sqrt underflow/overflow? - // Pass x to Math.sqrt as integer, then adjust the exponent of the result. - if ( s == 0 || s == 1 / 0 ) { - n = coeffToString(c); - if ( ( n.length + e ) % 2 == 0 ) n += '0'; - s = Math.sqrt(n); - e = bitFloor( ( e + 1 ) / 2 ) - ( e < 0 || e % 2 ); - - if ( s == 1 / 0 ) { - n = '1e' + e; - } else { - n = s.toExponential(); - n = n.slice( 0, n.indexOf('e') + 1 ) + e; - } - - r = new BigNumber(n); - } else { - r = new BigNumber( s + '' ); - } - - // Check for zero. - // r could be zero if MIN_EXP is changed after the this value was created. - // This would cause a division by zero (x/t) and hence Infinity below, which would cause - // coeffToString to throw. - if ( r.c[0] ) { - e = r.e; - s = e + dp; - if ( s < 3 ) s = 0; - - // Newton-Raphson iteration. - for ( ; ; ) { - t = r; - r = half.times( t.plus( div( x, t, dp, 1 ) ) ); - - if ( coeffToString( t.c ).slice( 0, s ) === ( n = - coeffToString( r.c ) ).slice( 0, s ) ) { - - // The exponent of r may here be one less than the final result exponent, - // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits - // are indexed correctly. - if ( r.e < e ) --s; - n = n.slice( s - 3, s + 1 ); - - // The 4th rounding digit may be in error by -1 so if the 4 rounding digits - // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the - // iteration. - if ( n == '9999' || !rep && n == '4999' ) { - - // On the first iteration only, check to see if rounding up gives the - // exact result as the nines may infinitely repeat. - if ( !rep ) { - round( t, t.e + DECIMAL_PLACES + 2, 0 ); - - if ( t.times(t).eq(x) ) { - r = t; - break; - } - } - - dp += 4; - s += 4; - rep = 1; - } else { - - // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact - // result. If not, then there are further digits and m will be truthy. - if ( !+n || !+n.slice(1) && n.charAt(0) == '5' ) { - - // Truncate to the first rounding digit. - round( r, r.e + DECIMAL_PLACES + 2, 1 ); - m = !r.times(r).eq(x); - } - - break; - } - } - } - } - - return round( r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m ); - }; - - - /* - * Return a string representing the value of this BigNumber in exponential notation and - * rounded using ROUNDING_MODE to dp fixed decimal places. - * - * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}' - */ - P.toExponential = function ( dp, rm ) { - if ( dp != null ) { - intCheck( dp, 0, MAX ); - dp++; - } - return format( this, dp, rm, 1 ); - }; - - - /* - * Return a string representing the value of this BigNumber in fixed-point notation rounding - * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted. - * - * Note: as with JavaScript's number type, (-0).toFixed(0) is '0', - * but e.g. (-0.00001).toFixed(0) is '-0'. - * - * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}' - */ - P.toFixed = function ( dp, rm ) { - if ( dp != null ) { - intCheck( dp, 0, MAX ); - dp = dp + this.e + 1; - } - return format( this, dp, rm ); - }; - - - /* - * Return a string representing the value of this BigNumber in fixed-point notation rounded - * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties - * of the FORMAT object (see BigNumber.set). - * - * FORMAT = { - * decimalSeparator : '.', - * groupSeparator : ',', - * groupSize : 3, - * secondaryGroupSize : 0, - * fractionGroupSeparator : '\xA0', // non-breaking space - * fractionGroupSize : 0 - * }; - * - * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}' - */ - P.toFormat = function ( dp, rm ) { - var str = this.toFixed( dp, rm ); - - if ( this.c ) { - var i, - arr = str.split('.'), - g1 = +FORMAT.groupSize, - g2 = +FORMAT.secondaryGroupSize, - groupSeparator = FORMAT.groupSeparator, - intPart = arr[0], - fractionPart = arr[1], - isNeg = this.s < 0, - intDigits = isNeg ? intPart.slice(1) : intPart, - len = intDigits.length; - - if (g2) i = g1, g1 = g2, g2 = i, len -= i; - - if ( g1 > 0 && len > 0 ) { - i = len % g1 || g1; - intPart = intDigits.substr( 0, i ); - - for ( ; i < len; i += g1 ) { - intPart += groupSeparator + intDigits.substr( i, g1 ); - } - - if ( g2 > 0 ) intPart += groupSeparator + intDigits.slice(i); - if (isNeg) intPart = '-' + intPart; - } - - str = fractionPart - ? intPart + FORMAT.decimalSeparator + ( ( g2 = +FORMAT.fractionGroupSize ) - ? fractionPart.replace( new RegExp( '\\d{' + g2 + '}\\B', 'g' ), - '$&' + FORMAT.fractionGroupSeparator ) - : fractionPart ) - : intPart; - } - - return str; - }; - - - /* - * Return 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 the specified maximum denominator. If a maximum - * denominator is not specified, the denominator will be the lowest value necessary to - * represent the number exactly. - * - * [md] {number|string|BigNumber} Integer >= 1 and < Infinity. The maximum denominator. - * - * '[BigNumber Error] Argument {not an integer|out of range} : {md}' - */ - P.toFraction = function (md) { - var arr, d, d0, d1, d2, e, exp, n, n0, n1, q, s, - x = this, - xc = x.c; - - if ( md != null ) { - n = new BigNumber(md); - - if ( !n.isInteger() || n.lt(ONE) ) { - throw Error - ( bignumberError + 'Argument ' + - ( n.isInteger() ? 'out of range: ' : 'not an integer: ' ) + md ); - } - } - - if ( !xc ) return x.toString(); - - d = new BigNumber(ONE); - n1 = d0 = new BigNumber(ONE); - d1 = n0 = new BigNumber(ONE); - s = coeffToString(xc); - - // Determine initial denominator. - // d is a power of 10 and the minimum max denominator that specifies the value exactly. - e = d.e = s.length - x.e - 1; - d.c[0] = POWS_TEN[ ( exp = e % LOG_BASE ) < 0 ? LOG_BASE + exp : exp ]; - md = !md || n.comparedTo(d) > 0 ? ( e > 0 ? d : n1 ) : n; - - exp = MAX_EXP; - MAX_EXP = 1 / 0; - n = new BigNumber(s); - - // n0 = d1 = 0 - n0.c[0] = 0; - - for ( ; ; ) { - q = div( n, d, 0, 1 ); - d2 = d0.plus( q.times(d1) ); - if ( d2.comparedTo(md) == 1 ) break; - d0 = d1; - d1 = d2; - n1 = n0.plus( q.times( d2 = n1 ) ); - n0 = d2; - d = n.minus( q.times( d2 = d ) ); - n = d2; - } - - d2 = div( md.minus(d0), d1, 0, 1 ); - n0 = n0.plus( d2.times(n1) ); - d0 = d0.plus( d2.times(d1) ); - n0.s = n1.s = x.s; - e *= 2; - - // Determine which fraction is closer to x, n0/d0 or n1/d1 - arr = div( n1, d1, e, ROUNDING_MODE ).minus(x).abs().comparedTo( - div( n0, d0, e, ROUNDING_MODE ).minus(x).abs() ) < 1 - ? [ n1.toString(), d1.toString() ] - : [ n0.toString(), d0.toString() ]; - - MAX_EXP = exp; - return arr; - }; - - - /* - * Return the value of this BigNumber converted to a number primitive. - */ - P.toNumber = function () { - return +this; - }; - - - /* - * Return a BigNumber whose value is the value of this BigNumber exponentiated by n. - * - * If m is present, return the result modulo m. - * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE. - * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE. - * - * The modular power operation works efficiently when x, n, and m are positive integers, - * otherwise it is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0. - * - * n {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive. - * [m] {number|string|BigNumber} The modulus. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {n}' - * - * Performs 54 loop iterations for n of 9007199254740991. - */ - P.exponentiatedBy = P.pow = function ( n, m ) { - var i, k, y, z, - x = this; - - intCheck( n, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER ); - if ( m != null ) m = new BigNumber(m); - - if (m) { - if ( n > 1 && x.gt(ONE) && x.isInteger() && m.gt(ONE) && m.isInteger() ) { - x = x.mod(m); - } else { - z = m; - - // Nullify m so only a single mod operation is performed at the end. - m = null; - } - } else if (POW_PRECISION) { - - // Truncating each coefficient array to a length of k after each multiplication - // equates to truncating significant digits to POW_PRECISION + [28, 41], - // i.e. there will be a minimum of 28 guard digits retained. - //k = mathceil( POW_PRECISION / LOG_BASE + 1.5 ); // gives [9, 21] guard digits. - k = mathceil( POW_PRECISION / LOG_BASE + 2 ); - } - - y = new BigNumber(ONE); - - for ( i = mathfloor( n < 0 ? -n : n ); ; ) { - if ( i % 2 ) { - y = y.times(x); - if ( !y.c ) break; - if (k) { - if ( y.c.length > k ) y.c.length = k; - } else if (m) { - y = y.mod(m); - } - } - - i = mathfloor( i / 2 ); - if ( !i ) break; - x = x.times(x); - if (k) { - if ( x.c && x.c.length > k ) x.c.length = k; - } else if (m) { - x = x.mod(m); - } - } - - if (m) return y; - if ( n < 0 ) y = ONE.div(y); - - return z ? y.mod(z) : k ? round( y, POW_PRECISION, ROUNDING_MODE ) : y; - }; - - - /* - * Return a string representing the value of this BigNumber rounded to sd significant digits - * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits - * necessary to represent the integer part of the value in fixed-point notation, then use - * exponential notation. - * - * [sd] {number} Significant digits. Integer, 1 to MAX inclusive. - * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. - * - * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}' - */ - P.toPrecision = function ( sd, rm ) { - if ( sd != null ) intCheck( sd, 1, MAX ); - return format( this, sd, rm, 2 ); - }; - - - /* - * Return a string representing the value of this BigNumber in base b, or base 10 if b is - * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and - * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent - * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than - * TO_EXP_NEG, return exponential notation. - * - * [b] {number} Integer, 2 to ALPHABET.length inclusive. - * - * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}' - */ - P.toString = function (b) { - var str, - n = this, - s = n.s, - e = n.e; - - // Infinity or NaN? - if ( e === null ) { - - if (s) { - str = 'Infinity'; - if ( s < 0 ) str = '-' + str; - } else { - str = 'NaN'; - } - } else { - str = coeffToString( n.c ); - - if ( b == null ) { - str = e <= TO_EXP_NEG || e >= TO_EXP_POS - ? toExponential( str, e ) - : toFixedPoint( str, e, '0' ); - } else { - intCheck( b, 2, ALPHABET.length, 'Base' ); - str = convertBase( toFixedPoint( str, e, '0' ), 10, b, s, true ); - } - - if ( s < 0 && n.c[0] ) str = '-' + str; - } - - return str; - }; - - - /* - * Return as toString, but do not accept a base argument, and include the minus sign for - * negative zero. - */ - P.valueOf = P.toJSON = function () { - var str, - n = this, - e = n.e; - - if ( e === null ) return n.toString(); - - str = coeffToString( n.c ); - - str = e <= TO_EXP_NEG || e >= TO_EXP_POS - ? toExponential( str, e ) - : toFixedPoint( str, e, '0' ); - - return n.s < 0 ? '-' + str : str; - }; - - - P._isBigNumber = true; - - if ( configObject != null ) BigNumber.set(configObject); - - return BigNumber; -} - - -// PRIVATE HELPER FUNCTIONS - - -function bitFloor(n) { - var i = n | 0; - return n > 0 || n === i ? i : i - 1; -} - - -// Return a coefficient array as a string of base 10 digits. -function coeffToString(a) { - var s, z, - i = 1, - j = a.length, - r = a[0] + ''; - - for ( ; i < j; ) { - s = a[i++] + ''; - z = LOG_BASE - s.length; - for ( ; z--; s = '0' + s ); - r += s; - } - - // Determine trailing zeros. - for ( j = r.length; r.charCodeAt(--j) === 48; ); - return r.slice( 0, j + 1 || 1 ); -} - - -// Compare the value of BigNumbers x and y. -function compare( x, y ) { - var a, b, - xc = x.c, - yc = y.c, - i = x.s, - j = y.s, - k = x.e, - l = y.e; - - // Either NaN? - if ( !i || !j ) return null; - - a = xc && !xc[0]; - b = yc && !yc[0]; - - // Either zero? - if ( a || b ) return a ? b ? 0 : -j : i; - - // Signs differ? - if ( i != j ) return i; - - a = i < 0; - b = k == l; - - // Either Infinity? - if ( !xc || !yc ) return b ? 0 : !xc ^ a ? 1 : -1; - - // Compare exponents. - if ( !b ) return k > l ^ a ? 1 : -1; - - j = ( k = xc.length ) < ( l = yc.length ) ? k : l; - - // Compare digit by digit. - for ( i = 0; i < j; i++ ) if ( xc[i] != yc[i] ) return xc[i] > yc[i] ^ a ? 1 : -1; - - // Compare lengths. - return k == l ? 0 : k > l ^ a ? 1 : -1; -} - - -/* - * Check that n is a primitive number, an integer, and in range, otherwise throw. - */ -function intCheck( n, min, max, name ) { - if ( n < min || n > max || n !== ( n < 0 ? mathceil(n) : mathfloor(n) ) ) { - throw Error - ( bignumberError + ( name || 'Argument' ) + ( typeof n == 'number' - ? n < min || n > max ? ' out of range: ' : ' not an integer: ' - : ' not a primitive number: ' ) + n ); - } -} - - -function isArray(obj) { - return Object.prototype.toString.call(obj) == '[object Array]'; -} - - -function toExponential( str, e ) { - return ( str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str ) + - ( e < 0 ? 'e' : 'e+' ) + e; -} - - -function toFixedPoint( str, e, z ) { - var len, zs; - - // Negative exponent? - if ( e < 0 ) { - - // Prepend zeros. - for ( zs = z + '.'; ++e; zs += z ); - str = zs + str; - - // Positive exponent - } else { - len = str.length; - - // Append zeros. - if ( ++e > len ) { - for ( zs = z, e -= len; --e; zs += z ); - str += zs; - } else if ( e < len ) { - str = str.slice( 0, e ) + '.' + str.slice(e); - } - } - - return str; -} - - -// EXPORT - - -BigNumber = clone(); -BigNumber['default'] = BigNumber.BigNumber = BigNumber; - -export default BigNumber;
\ No newline at end of file diff --git a/packages/instant/test/util/maybe_big_number.test.ts b/packages/instant/test/util/maybe_big_number.test.ts index f32e33eb1..508e8aaf0 100644 --- a/packages/instant/test/util/maybe_big_number.test.ts +++ b/packages/instant/test/util/maybe_big_number.test.ts @@ -2,12 +2,9 @@ import { BigNumber } from '@0x/utils'; import { maybeBigNumberUtil } from '../../src/util/maybe_big_number'; -// import PrevBigNumber from './dependencies/prevbignumber'; - const BIG_NUMBER_1 = new BigNumber('10.1'); const BIG_NUMBER_2 = new BigNumber('10.1'); const BIG_NUMBER_3 = new BigNumber('11.1'); -// const PREVBIG_NUMBER_1 = new PrevBigNumber('11.1'); describe('maybeBigNumberUtil', () => { describe('stringToMaybeBigNumber', () => { @@ -40,32 +37,29 @@ describe('maybeBigNumberUtil', () => { }); }); - // describe('bigNumberOrStringToMaybeBigNumber', () => { - // it('should return BigNumber (>=v8.0.0) constructed with value if type is string', () => { - // const bn = maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber('10.1'); - // if (!!bn) { - // expect(bn.toString()).toEqual('10.1'); - // } - // }); - // it('should return undefined if value is NaN', () => { - // expect(maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber('NaN')).toEqual(undefined); - // }); - // it('should return undefined if value as string is not valid (i.e not numeric)', () => { - // expect(maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber('test')).toEqual(undefined); - // }); - // it('should return undefined if value as string is not valid (i.e not numeric)', () => { - // expect(maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber('test')).toEqual(undefined); - // }); - // it('should return BigNumber (>=v8.0.0) when passed a value as BigNumber (<v8.0.0)', () => { - // const bn = maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber(PREVBIG_NUMBER_1); - // expect(BigNumber.isBigNumber(bn)).toEqual(true); - // }); - // it('should return BigNumber (>=v8.0.0) when passed a value as BigNumber (>=v8.0.0)', () => { - // const bn = maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber(BIG_NUMBER_1); - // expect(BigNumber.isBigNumber(bn)).toEqual(true); - // }); - // it('should return undefined if value is not BigNumber or string', () => { - // expect(maybeBigNumberUtil.bigNumberOrStringToMaybeBigNumber(true)).toEqual(undefined); - // }); - // }); + // this doesn't test coercing a pre v8.0.0 version of big number to desired version + describe('toMaybeBigNumber', () => { + it('should return BigNumber (>=v8.0.0) constructed with value if type is string', () => { + const bn = maybeBigNumberUtil.toMaybeBigNumber('10.1'); + if (!!bn) { + expect(bn.toString()).toEqual('10.1'); + } + }); + it('should return undefined if value is NaN', () => { + expect(maybeBigNumberUtil.toMaybeBigNumber('NaN')).toEqual(undefined); + }); + it('should return undefined if value as string is not valid (i.e not numeric)', () => { + expect(maybeBigNumberUtil.toMaybeBigNumber('test')).toEqual(undefined); + }); + it('should return undefined if value as string is not valid (i.e not numeric)', () => { + expect(maybeBigNumberUtil.toMaybeBigNumber('test')).toEqual(undefined); + }); + it('should return BigNumber (>=v8.0.0) when passed a value as BigNumber (>=v8.0.0)', () => { + const bn = maybeBigNumberUtil.toMaybeBigNumber(BIG_NUMBER_1); + expect(BigNumber.isBigNumber(bn)).toEqual(true); + }); + it('should return undefined if value is not BigNumber or string', () => { + expect(maybeBigNumberUtil.toMaybeBigNumber(true)).toEqual(undefined); + }); + }); }); diff --git a/packages/instant/test/util/order_coercion.test.ts b/packages/instant/test/util/order_coercion.test.ts new file mode 100644 index 000000000..f7a958c9d --- /dev/null +++ b/packages/instant/test/util/order_coercion.test.ts @@ -0,0 +1,103 @@ +import { BigNumber } from '@0x/utils'; + +import { orderCoercionUtil } from '../../src/util/order_coercion'; + +const ORDER = { + senderAddress: '0x0000000000000000000000000000000000000000', + makerAddress: '0x34a745008a643eebc58920eaa29fb1165b4a288e', + takerAddress: '0x0000000000000000000000000000000000000000', + makerFee: new BigNumber('0'), + takerFee: new BigNumber('0'), + makerAssetAmount: new BigNumber('200000000000000000000'), + takerAssetAmount: new BigNumber('10000000000000000000'), + makerAssetData: '0xf47261b00000000000000000000000008cb3971b8eb709c14616bd556ff6683019e90d9c', + takerAssetData: '0xf47261b0000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c', + expirationTimeSeconds: new BigNumber('1601535600'), + feeRecipientAddress: '0x0000000000000000000000000000000000000000', + salt: new BigNumber('3101985707338942582579795423923841749956600670712030922928319824580764688653'), + signature: + '0x1bd4d5686fea801fe33c68c4944356085e7e6cb553eb7073160abd815609f714e85fb47f44b7ffd0a2a1321ac40d72d55163869d0a50fdb5a402132150fe33a08403', + exchangeAddress: '0x35dd2932454449b14cee11a94d3674a936d5d7b2', +}; + +const STRING_ORDER = { + senderAddress: '0x0000000000000000000000000000000000000000', + makerAddress: '0x34a745008a643eebc58920eaa29fb1165b4a288e', + takerAddress: '0x0000000000000000000000000000000000000000', + makerFee: '0', + takerFee: '0', + makerAssetAmount: '300000000000000000000', + takerAssetAmount: '31000000000000000000', + makerAssetData: '0xf47261b00000000000000000000000002002d3812f58e35f0ea1ffbf80a75a38c32175fa', + takerAssetData: '0xf47261b0000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c', + expirationTimeSeconds: '2524636800', + feeRecipientAddress: '0x0000000000000000000000000000000000000000', + salt: '64592004666704945574675477805199411288137454783320798602050822322450089238268', + signature: + '0x1c13cacddca8d7d8248e91f412377e68f8f1f9891a59a6c1b2eea9f7b33558c30c4fb86a448e08ab7def40a28fb3a3062dcb33bb3c45302447fce5c4288b7c7f5b03', + exchangeAddress: '0x35dd2932454449b14cee11a94d3674a936d5d7b2', +}; + +const ORDERS = [ORDER, STRING_ORDER]; + +describe('orderCoercionUtil', () => { + describe('coerceFieldsToBigNumbers', () => { + it('should coerce all fields specified to a big number', () => { + const coercedOrder = orderCoercionUtil.coerceFieldsToBigNumbers(STRING_ORDER, ['makerFee', 'takerFee']); + expect(coercedOrder.makerFee.toString()).toEqual('0'); + expect(coercedOrder.takerFee.toString()).toEqual('0'); + }); + it("should throw if a field can't be found", () => { + expect(() => { + orderCoercionUtil.coerceFieldsToBigNumbers(ORDER, ['salty']); + }).toThrow("Could not find field 'salty' while converting fields to BigNumber."); + }); + it('should not change value if not numeric string or big number', () => { + const obj = { number: 'number' }; + const coercedObj = orderCoercionUtil.coerceFieldsToBigNumbers(obj, ['number']); + expect(coercedObj).toEqual({ + number: 'number', + }); + }); + }); + // Note: this doesn't test coercing pre v8.0.0 BigNumber versions to specified one used by 0x + describe('coerceOrderFieldsToBigNumber', () => { + it('should convert string values in order to big number', () => { + const coercedOrder = orderCoercionUtil.coerceOrderFieldsToBigNumber(STRING_ORDER); + expect(coercedOrder.makerFee.toString()).toEqual(STRING_ORDER.makerFee); + expect(coercedOrder.takerFee.toString()).toEqual(STRING_ORDER.takerFee); + expect(coercedOrder.takerAssetAmount.toString()).toEqual(STRING_ORDER.takerAssetAmount); + expect(coercedOrder.makerAssetAmount.toString()).toEqual(STRING_ORDER.makerAssetAmount); + expect(coercedOrder.salt.toString()).toEqual(STRING_ORDER.salt); + expect(coercedOrder.expirationTimeSeconds.toString()).toEqual(STRING_ORDER.expirationTimeSeconds); + }); + it('should convert big number values in order to big number', () => { + const coercedOrder = orderCoercionUtil.coerceOrderFieldsToBigNumber(ORDER); + expect(coercedOrder.makerFee).toEqual(ORDER.makerFee); + expect(coercedOrder.takerFee).toEqual(ORDER.takerFee); + expect(coercedOrder.takerAssetAmount).toEqual(ORDER.takerAssetAmount); + expect(coercedOrder.makerAssetAmount).toEqual(ORDER.makerAssetAmount); + expect(coercedOrder.salt).toEqual(ORDER.salt); + expect(coercedOrder.expirationTimeSeconds).toEqual(ORDER.expirationTimeSeconds); + }); + }); + // Note: this doesn't test coercing pre v8.0.0 BigNumber versions to specified one used by 0x + describe('coerceOrderArrayFieldsToBigNumber', () => { + it('should convert string values and big numbers in orders to big number', () => { + const coercedOrders = orderCoercionUtil.coerceOrderArrayFieldsToBigNumber(ORDERS); + expect(coercedOrders[0].makerFee).toEqual(ORDER.makerFee); + expect(coercedOrders[0].takerFee).toEqual(ORDER.takerFee); + expect(coercedOrders[0].takerAssetAmount).toEqual(ORDER.takerAssetAmount); + expect(coercedOrders[0].makerAssetAmount).toEqual(ORDER.makerAssetAmount); + expect(coercedOrders[0].salt).toEqual(ORDER.salt); + expect(coercedOrders[0].expirationTimeSeconds).toEqual(ORDER.expirationTimeSeconds); + + expect(coercedOrders[1].makerFee.toString()).toEqual(STRING_ORDER.makerFee); + expect(coercedOrders[1].takerFee.toString()).toEqual(STRING_ORDER.takerFee); + expect(coercedOrders[1].takerAssetAmount.toString()).toEqual(STRING_ORDER.takerAssetAmount); + expect(coercedOrders[1].makerAssetAmount.toString()).toEqual(STRING_ORDER.makerAssetAmount); + expect(coercedOrders[1].salt.toString()).toEqual(STRING_ORDER.salt); + expect(coercedOrders[1].expirationTimeSeconds.toString()).toEqual(STRING_ORDER.expirationTimeSeconds); + }); + }); +}); |