1 | // Type definitions for bignumber.js >=8.1.0
|
2 | // Project: https://github.com/MikeMcl/bignumber.js
|
3 | // Definitions by: Michael Mclaughlin <https://github.com/MikeMcl>
|
4 | // Definitions: https://github.com/MikeMcl/bignumber.js
|
5 |
|
6 | // Documentation: http://mikemcl.github.io/bignumber.js/
|
7 | //
|
8 | // Exports:
|
9 | //
|
10 | // class BigNumber (default export)
|
11 | // type BigNumber.Constructor
|
12 | // type BigNumber.ModuloMode
|
13 | // type BigNumber.RoundingMode
|
14 | // type BigNumber.Value
|
15 | // interface BigNumber.Config
|
16 | // interface BigNumber.Format
|
17 | // interface BigNumber.Instance
|
18 | //
|
19 | // Example:
|
20 | //
|
21 | // import {BigNumber} from "bignumber.js"
|
22 | // //import BigNumber from "bignumber.js"
|
23 | //
|
24 | // let rm: BigNumber.RoundingMode = BigNumber.ROUND_UP;
|
25 | // let f: BigNumber.Format = { decimalSeparator: ',' };
|
26 | // let c: BigNumber.Config = { DECIMAL_PLACES: 4, ROUNDING_MODE: rm, FORMAT: f };
|
27 | // BigNumber.config(c);
|
28 | //
|
29 | // let v: BigNumber.Value = '12345.6789';
|
30 | // let b: BigNumber = new BigNumber(v);
|
31 | //
|
32 | // The use of compiler option `--strictNullChecks` is recommended.
|
33 |
|
34 | export default BigNumber;
|
35 |
|
36 | export namespace BigNumber {
|
37 |
|
38 | /** See `BigNumber.config` (alias `BigNumber.set`) and `BigNumber.clone`. */
|
39 | interface Config {
|
40 |
|
41 | /**
|
42 | * An integer, 0 to 1e+9. Default value: 20.
|
43 | *
|
44 | * The maximum number of decimal places of the result of operations involving division, i.e.
|
45 | * division, square root and base conversion operations, and exponentiation when the exponent is
|
46 | * negative.
|
47 | *
|
48 | * ```ts
|
49 | * BigNumber.config({ DECIMAL_PLACES: 5 })
|
50 | * BigNumber.set({ DECIMAL_PLACES: 5 })
|
51 | * ```
|
52 | */
|
53 | DECIMAL_PLACES?: number;
|
54 |
|
55 | /**
|
56 | * An integer, 0 to 8. Default value: `BigNumber.ROUND_HALF_UP` (4).
|
57 | *
|
58 | * The rounding mode used in operations that involve division (see `DECIMAL_PLACES`) and the
|
59 | * default rounding mode of the `decimalPlaces`, `precision`, `toExponential`, `toFixed`,
|
60 | * `toFormat` and `toPrecision` methods.
|
61 | *
|
62 | * The modes are available as enumerated properties of the BigNumber constructor.
|
63 | *
|
64 | * ```ts
|
65 | * BigNumber.config({ ROUNDING_MODE: 0 })
|
66 | * BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP })
|
67 | * ```
|
68 | */
|
69 | ROUNDING_MODE?: BigNumber.RoundingMode;
|
70 |
|
71 | /**
|
72 | * An integer, 0 to 1e+9, or an array, [-1e+9 to 0, 0 to 1e+9].
|
73 | * Default value: `[-7, 20]`.
|
74 | *
|
75 | * The exponent value(s) at which `toString` returns exponential notation.
|
76 | *
|
77 | * If a single number is assigned, the value is the exponent magnitude.
|
78 | *
|
79 | * If an array of two numbers is assigned then the first number is the negative exponent value at
|
80 | * and beneath which exponential notation is used, and the second number is the positive exponent
|
81 | * value at and above which exponential notation is used.
|
82 | *
|
83 | * For example, to emulate JavaScript numbers in terms of the exponent values at which they begin
|
84 | * to use exponential notation, use `[-7, 20]`.
|
85 | *
|
86 | * ```ts
|
87 | * BigNumber.config({ EXPONENTIAL_AT: 2 })
|
88 | * new BigNumber(12.3) // '12.3' e is only 1
|
89 | * new BigNumber(123) // '1.23e+2'
|
90 | * new BigNumber(0.123) // '0.123' e is only -1
|
91 | * new BigNumber(0.0123) // '1.23e-2'
|
92 | *
|
93 | * BigNumber.config({ EXPONENTIAL_AT: [-7, 20] })
|
94 | * new BigNumber(123456789) // '123456789' e is only 8
|
95 | * new BigNumber(0.000000123) // '1.23e-7'
|
96 | *
|
97 | * // Almost never return exponential notation:
|
98 | * BigNumber.config({ EXPONENTIAL_AT: 1e+9 })
|
99 | *
|
100 | * // Always return exponential notation:
|
101 | * BigNumber.config({ EXPONENTIAL_AT: 0 })
|
102 | * ```
|
103 | *
|
104 | * Regardless of the value of `EXPONENTIAL_AT`, the `toFixed` method will always return a value in
|
105 | * normal notation and the `toExponential` method will always return a value in exponential form.
|
106 | * Calling `toString` with a base argument, e.g. `toString(10)`, will also always return normal
|
107 | * notation.
|
108 | */
|
109 | EXPONENTIAL_AT?: number | [number, number];
|
110 |
|
111 | /**
|
112 | * An integer, magnitude 1 to 1e+9, or an array, [-1e+9 to -1, 1 to 1e+9].
|
113 | * Default value: `[-1e+9, 1e+9]`.
|
114 | *
|
115 | * The exponent value(s) beyond which overflow to Infinity and underflow to zero occurs.
|
116 | *
|
117 | * If a single number is assigned, it is the maximum exponent magnitude: values wth a positive
|
118 | * exponent of greater magnitude become Infinity and those with a negative exponent of greater
|
119 | * magnitude become zero.
|
120 | *
|
121 | * If an array of two numbers is assigned then the first number is the negative exponent limit and
|
122 | * the second number is the positive exponent limit.
|
123 | *
|
124 | * For example, to emulate JavaScript numbers in terms of the exponent values at which they
|
125 | * become zero and Infinity, use [-324, 308].
|
126 | *
|
127 | * ```ts
|
128 | * BigNumber.config({ RANGE: 500 })
|
129 | * BigNumber.config().RANGE // [ -500, 500 ]
|
130 | * new BigNumber('9.999e499') // '9.999e+499'
|
131 | * new BigNumber('1e500') // 'Infinity'
|
132 | * new BigNumber('1e-499') // '1e-499'
|
133 | * new BigNumber('1e-500') // '0'
|
134 | *
|
135 | * BigNumber.config({ RANGE: [-3, 4] })
|
136 | * new BigNumber(99999) // '99999' e is only 4
|
137 | * new BigNumber(100000) // 'Infinity' e is 5
|
138 | * new BigNumber(0.001) // '0.01' e is only -3
|
139 | * new BigNumber(0.0001) // '0' e is -4
|
140 | * ```
|
141 | * The largest possible magnitude of a finite BigNumber is 9.999...e+1000000000.
|
142 | * The smallest possible magnitude of a non-zero BigNumber is 1e-1000000000.
|
143 | */
|
144 | RANGE?: number | [number, number];
|
145 |
|
146 | /**
|
147 | * A boolean: `true` or `false`. Default value: `false`.
|
148 | *
|
149 | * The value that determines whether cryptographically-secure pseudo-random number generation is
|
150 | * used. If `CRYPTO` is set to true then the random method will generate random digits using
|
151 | * `crypto.getRandomValues` in browsers that support it, or `crypto.randomBytes` if using a
|
152 | * version of Node.js that supports it.
|
153 | *
|
154 | * If neither function is supported by the host environment then attempting to set `CRYPTO` to
|
155 | * `true` will fail and an exception will be thrown.
|
156 | *
|
157 | * If `CRYPTO` is `false` then the source of randomness used will be `Math.random` (which is
|
158 | * assumed to generate at least 30 bits of randomness).
|
159 | *
|
160 | * See `BigNumber.random`.
|
161 | *
|
162 | * ```ts
|
163 | * // Node.js
|
164 | * global.crypto = require('crypto')
|
165 | *
|
166 | * BigNumber.config({ CRYPTO: true })
|
167 | * BigNumber.config().CRYPTO // true
|
168 | * BigNumber.random() // 0.54340758610486147524
|
169 | * ```
|
170 | */
|
171 | CRYPTO?: boolean;
|
172 |
|
173 | /**
|
174 | * An integer, 0, 1, 3, 6 or 9. Default value: `BigNumber.ROUND_DOWN` (1).
|
175 | *
|
176 | * The modulo mode used when calculating the modulus: `a mod n`.
|
177 | * The quotient, `q = a / n`, is calculated according to the `ROUNDING_MODE` that corresponds to
|
178 | * the chosen `MODULO_MODE`.
|
179 | * The remainder, `r`, is calculated as: `r = a - n * q`.
|
180 | *
|
181 | * The modes that are most commonly used for the modulus/remainder operation are shown in the
|
182 | * following table. Although the other rounding modes can be used, they may not give useful
|
183 | * results.
|
184 | *
|
185 | * Property | Value | Description
|
186 | * :------------------|:------|:------------------------------------------------------------------
|
187 | * `ROUND_UP` | 0 | The remainder is positive if the dividend is negative.
|
188 | * `ROUND_DOWN` | 1 | The remainder has the same sign as the dividend.
|
189 | * | | Uses 'truncating division' and matches JavaScript's `%` operator .
|
190 | * `ROUND_FLOOR` | 3 | The remainder has the same sign as the divisor.
|
191 | * | | This matches Python's `%` operator.
|
192 | * `ROUND_HALF_EVEN` | 6 | The IEEE 754 remainder function.
|
193 | * `EUCLID` | 9 | The remainder is always positive.
|
194 | * | | Euclidian division: `q = sign(n) * floor(a / abs(n))`
|
195 | *
|
196 | * The rounding/modulo modes are available as enumerated properties of the BigNumber constructor.
|
197 | *
|
198 | * See `modulo`.
|
199 | *
|
200 | * ```ts
|
201 | * BigNumber.config({ MODULO_MODE: BigNumber.EUCLID })
|
202 | * BigNumber.set({ MODULO_MODE: 9 }) // equivalent
|
203 | * ```
|
204 | */
|
205 | MODULO_MODE?: BigNumber.ModuloMode;
|
206 |
|
207 | /**
|
208 | * An integer, 0 to 1e+9. Default value: 0.
|
209 | *
|
210 | * The maximum precision, i.e. number of significant digits, of the result of the power operation
|
211 | * - unless a modulus is specified.
|
212 | *
|
213 | * If set to 0, the number of significant digits will not be limited.
|
214 | *
|
215 | * See `exponentiatedBy`.
|
216 | *
|
217 | * ```ts
|
218 | * BigNumber.config({ POW_PRECISION: 100 })
|
219 | * ```
|
220 | */
|
221 | POW_PRECISION?: number;
|
222 |
|
223 | /**
|
224 | * An object including any number of the properties shown below.
|
225 | *
|
226 | * The object configures the format of the string returned by the `toFormat` method.
|
227 | * The example below shows the properties of the object that are recognised, and
|
228 | * their default values.
|
229 | *
|
230 | * Unlike the other configuration properties, the values of the properties of the `FORMAT` object
|
231 | * will not be checked for validity - the existing object will simply be replaced by the object
|
232 | * that is passed in.
|
233 | *
|
234 | * See `toFormat`.
|
235 | *
|
236 | * ```ts
|
237 | * BigNumber.config({
|
238 | * FORMAT: {
|
239 | * // string to prepend
|
240 | * prefix: '',
|
241 | * // the decimal separator
|
242 | * decimalSeparator: '.',
|
243 | * // the grouping separator of the integer part
|
244 | * groupSeparator: ',',
|
245 | * // the primary grouping size of the integer part
|
246 | * groupSize: 3,
|
247 | * // the secondary grouping size of the integer part
|
248 | * secondaryGroupSize: 0,
|
249 | * // the grouping separator of the fraction part
|
250 | * fractionGroupSeparator: ' ',
|
251 | * // the grouping size of the fraction part
|
252 | * fractionGroupSize: 0,
|
253 | * // string to append
|
254 | * suffix: ''
|
255 | * }
|
256 | * })
|
257 | * ```
|
258 | */
|
259 | FORMAT?: BigNumber.Format;
|
260 |
|
261 | /**
|
262 | * The alphabet used for base conversion. The length of the alphabet corresponds to the maximum
|
263 | * value of the base argument that can be passed to the BigNumber constructor or `toString`.
|
264 | *
|
265 | * Default value: `'0123456789abcdefghijklmnopqrstuvwxyz'`.
|
266 | *
|
267 | * There is no maximum length for the alphabet, but it must be at least 2 characters long,
|
268 | * and it must not contain whitespace or a repeated character, or the sign indicators '+' and
|
269 | * '-', or the decimal separator '.'.
|
270 | *
|
271 | * ```ts
|
272 | * // duodecimal (base 12)
|
273 | * BigNumber.config({ ALPHABET: '0123456789TE' })
|
274 | * x = new BigNumber('T', 12)
|
275 | * x.toString() // '10'
|
276 | * x.toString(12) // 'T'
|
277 | * ```
|
278 | */
|
279 | ALPHABET?: string;
|
280 | }
|
281 |
|
282 | /** See `FORMAT` and `toFormat`. */
|
283 | interface Format {
|
284 |
|
285 | /** The string to prepend. */
|
286 | prefix?: string;
|
287 |
|
288 | /** The decimal separator. */
|
289 | decimalSeparator?: string;
|
290 |
|
291 | /** The grouping separator of the integer part. */
|
292 | groupSeparator?: string;
|
293 |
|
294 | /** The primary grouping size of the integer part. */
|
295 | groupSize?: number;
|
296 |
|
297 | /** The secondary grouping size of the integer part. */
|
298 | secondaryGroupSize?: number;
|
299 |
|
300 | /** The grouping separator of the fraction part. */
|
301 | fractionGroupSeparator?: string;
|
302 |
|
303 | /** The grouping size of the fraction part. */
|
304 | fractionGroupSize?: number;
|
305 |
|
306 | /** The string to append. */
|
307 | suffix?: string;
|
308 | }
|
309 |
|
310 | interface Instance {
|
311 |
|
312 | /** The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers, or null. */
|
313 | readonly c: number[] | null;
|
314 |
|
315 | /** The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000, or null. */
|
316 | readonly e: number | null;
|
317 |
|
318 | /** The sign of the value of this BigNumber, -1, 1, or null. */
|
319 | readonly s: number | null;
|
320 |
|
321 | [key: string]: any;
|
322 | }
|
323 |
|
324 | type Constructor = typeof BigNumber;
|
325 | type ModuloMode = 0 | 1 | 3 | 6 | 9;
|
326 | type RoundingMode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
|
327 | type Value = string | number | Instance;
|
328 | }
|
329 |
|
330 | export declare class BigNumber implements BigNumber.Instance {
|
331 |
|
332 | /** Used internally to identify a BigNumber instance. */
|
333 | private readonly _isBigNumber: true;
|
334 |
|
335 | /** The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers, or null. */
|
336 | readonly c: number[] | null;
|
337 |
|
338 | /** The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000, or null. */
|
339 | readonly e: number | null;
|
340 |
|
341 | /** The sign of the value of this BigNumber, -1, 1, or null. */
|
342 | readonly s: number | null;
|
343 |
|
344 | /**
|
345 | * Returns a new instance of a BigNumber object with value `n`, where `n` is a numeric value in
|
346 | * the specified `base`, or base 10 if `base` is omitted or is `null` or `undefined`.
|
347 | *
|
348 | * ```ts
|
349 | * x = new BigNumber(123.4567) // '123.4567'
|
350 | * // 'new' is optional
|
351 | * y = BigNumber(x) // '123.4567'
|
352 | * ```
|
353 | *
|
354 | * If `n` is a base 10 value it can be in normal (fixed-point) or exponential notation.
|
355 | * Values in other bases must be in normal notation. Values in any base can have fraction digits,
|
356 | * i.e. digits after the decimal point.
|
357 | *
|
358 | * ```ts
|
359 | * new BigNumber(43210) // '43210'
|
360 | * new BigNumber('4.321e+4') // '43210'
|
361 | * new BigNumber('-735.0918e-430') // '-7.350918e-428'
|
362 | * new BigNumber('123412421.234324', 5) // '607236.557696'
|
363 | * ```
|
364 | *
|
365 | * Signed `0`, signed `Infinity` and `NaN` are supported.
|
366 | *
|
367 | * ```ts
|
368 | * new BigNumber('-Infinity') // '-Infinity'
|
369 | * new BigNumber(NaN) // 'NaN'
|
370 | * new BigNumber(-0) // '0'
|
371 | * new BigNumber('.5') // '0.5'
|
372 | * new BigNumber('+2') // '2'
|
373 | * ```
|
374 | *
|
375 | * String values in hexadecimal literal form, e.g. `'0xff'`, are valid, as are string values with
|
376 | * the octal and binary prefixs `'0o'` and `'0b'`. String values in octal literal form without the
|
377 | * prefix will be interpreted as decimals, e.g. `'011'` is interpreted as 11, not 9.
|
378 | *
|
379 | * ```ts
|
380 | * new BigNumber(-10110100.1, 2) // '-180.5'
|
381 | * new BigNumber('-0b10110100.1') // '-180.5'
|
382 | * new BigNumber('ff.8', 16) // '255.5'
|
383 | * new BigNumber('0xff.8') // '255.5'
|
384 | * ```
|
385 | *
|
386 | * If a base is specified, `n` is rounded according to the current `DECIMAL_PLACES` and
|
387 | * `ROUNDING_MODE` settings. This includes base 10, so don't include a `base` parameter for decimal
|
388 | * values unless this behaviour is desired.
|
389 | *
|
390 | * ```ts
|
391 | * BigNumber.config({ DECIMAL_PLACES: 5 })
|
392 | * new BigNumber(1.23456789) // '1.23456789'
|
393 | * new BigNumber(1.23456789, 10) // '1.23457'
|
394 | * ```
|
395 | *
|
396 | * An error is thrown if `base` is invalid.
|
397 | *
|
398 | * There is no limit to the number of digits of a value of type string (other than that of
|
399 | * JavaScript's maximum array size). See `RANGE` to set the maximum and minimum possible exponent
|
400 | * value of a BigNumber.
|
401 | *
|
402 | * ```ts
|
403 | * new BigNumber('5032485723458348569331745.33434346346912144534543')
|
404 | * new BigNumber('4.321e10000000')
|
405 | * ```
|
406 | *
|
407 | * BigNumber `NaN` is returned if `n` is invalid (unless `BigNumber.DEBUG` is `true`, see below).
|
408 | *
|
409 | * ```ts
|
410 | * new BigNumber('.1*') // 'NaN'
|
411 | * new BigNumber('blurgh') // 'NaN'
|
412 | * new BigNumber(9, 2) // 'NaN'
|
413 | * ```
|
414 | *
|
415 | * To aid in debugging, if `BigNumber.DEBUG` is `true` then an error will be thrown on an
|
416 | * invalid `n`. An error will also be thrown if `n` is of type number with more than 15
|
417 | * significant digits, as calling `toString` or `valueOf` on these numbers may not result in the
|
418 | * intended value.
|
419 | *
|
420 | * ```ts
|
421 | * console.log(823456789123456.3) // 823456789123456.2
|
422 | * new BigNumber(823456789123456.3) // '823456789123456.2'
|
423 | * BigNumber.DEBUG = true
|
424 | * // 'Error: Number has more than 15 significant digits'
|
425 | * new BigNumber(823456789123456.3)
|
426 | * // 'Error: Not a base 2 number'
|
427 | * new BigNumber(9, 2)
|
428 | * ```
|
429 | *
|
430 | * A BigNumber can also be created from an object literal.
|
431 | * Use `isBigNumber` to check that it is well-formed.
|
432 | *
|
433 | * ```ts
|
434 | * new BigNumber({ s: 1, e: 2, c: [ 777, 12300000000000 ], _isBigNumber: true }) // '777.123'
|
435 | * ```
|
436 | *
|
437 | * @param n A numeric value.
|
438 | * @param base The base of `n`, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`).
|
439 | */
|
440 | constructor(n: BigNumber.Value, base?: number);
|
441 |
|
442 | /**
|
443 | * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this
|
444 | * BigNumber.
|
445 | *
|
446 | * The return value is always exact and unrounded.
|
447 | *
|
448 | * ```ts
|
449 | * x = new BigNumber(-0.8)
|
450 | * x.absoluteValue() // '0.8'
|
451 | * ```
|
452 | */
|
453 | absoluteValue(): BigNumber;
|
454 |
|
455 | /**
|
456 | * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this
|
457 | * BigNumber.
|
458 | *
|
459 | * The return value is always exact and unrounded.
|
460 | *
|
461 | * ```ts
|
462 | * x = new BigNumber(-0.8)
|
463 | * x.abs() // '0.8'
|
464 | * ```
|
465 | */
|
466 | abs(): BigNumber;
|
467 |
|
468 | /**
|
469 | * Returns | |
|
470 | * :-------:|:--------------------------------------------------------------|
|
471 | * 1 | If the value of this BigNumber is greater than the value of `n`
|
472 | * -1 | If the value of this BigNumber is less than the value of `n`
|
473 | * 0 | If this BigNumber and `n` have the same value
|
474 | * `null` | If the value of either this BigNumber or `n` is `NaN`
|
475 | *
|
476 | * ```ts
|
477 | *
|
478 | * x = new BigNumber(Infinity)
|
479 | * y = new BigNumber(5)
|
480 | * x.comparedTo(y) // 1
|
481 | * x.comparedTo(x.minus(1)) // 0
|
482 | * y.comparedTo(NaN) // null
|
483 | * y.comparedTo('110', 2) // -1
|
484 | * ```
|
485 | * @param n A numeric value.
|
486 | * @param [base] The base of n.
|
487 | */
|
488 | comparedTo(n: BigNumber.Value, base?: number): number;
|
489 |
|
490 | /**
|
491 | * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode
|
492 | * `roundingMode` to a maximum of `decimalPlaces` decimal places.
|
493 | *
|
494 | * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of
|
495 | * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is
|
496 | * ±`Infinity` or `NaN`.
|
497 | *
|
498 | * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
499 | *
|
500 | * Throws if `decimalPlaces` or `roundingMode` is invalid.
|
501 | *
|
502 | * ```ts
|
503 | * x = new BigNumber(1234.56)
|
504 | * x.decimalPlaces() // 2
|
505 | * x.decimalPlaces(1) // '1234.6'
|
506 | * x.decimalPlaces(2) // '1234.56'
|
507 | * x.decimalPlaces(10) // '1234.56'
|
508 | * x.decimalPlaces(0, 1) // '1234'
|
509 | * x.decimalPlaces(0, 6) // '1235'
|
510 | * x.decimalPlaces(1, 1) // '1234.5'
|
511 | * x.decimalPlaces(1, BigNumber.ROUND_HALF_EVEN) // '1234.6'
|
512 | * x // '1234.56'
|
513 | * y = new BigNumber('9.9e-101')
|
514 | * y.decimalPlaces() // 102
|
515 | * ```
|
516 | *
|
517 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
518 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
519 | */
|
520 | decimalPlaces(): number | null;
|
521 | decimalPlaces(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
|
522 |
|
523 | /**
|
524 | * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode
|
525 | * `roundingMode` to a maximum of `decimalPlaces` decimal places.
|
526 | *
|
527 | * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of
|
528 | * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is
|
529 | * ±`Infinity` or `NaN`.
|
530 | *
|
531 | * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
532 | *
|
533 | * Throws if `decimalPlaces` or `roundingMode` is invalid.
|
534 | *
|
535 | * ```ts
|
536 | * x = new BigNumber(1234.56)
|
537 | * x.dp() // 2
|
538 | * x.dp(1) // '1234.6'
|
539 | * x.dp(2) // '1234.56'
|
540 | * x.dp(10) // '1234.56'
|
541 | * x.dp(0, 1) // '1234'
|
542 | * x.dp(0, 6) // '1235'
|
543 | * x.dp(1, 1) // '1234.5'
|
544 | * x.dp(1, BigNumber.ROUND_HALF_EVEN) // '1234.6'
|
545 | * x // '1234.56'
|
546 | * y = new BigNumber('9.9e-101')
|
547 | * y.dp() // 102
|
548 | * ```
|
549 | *
|
550 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
551 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
552 | */
|
553 | dp(): number | null;
|
554 | dp(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
|
555 |
|
556 | /**
|
557 | * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded
|
558 | * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
|
559 | *
|
560 | * ```ts
|
561 | * x = new BigNumber(355)
|
562 | * y = new BigNumber(113)
|
563 | * x.dividedBy(y) // '3.14159292035398230088'
|
564 | * x.dividedBy(5) // '71'
|
565 | * x.dividedBy(47, 16) // '5'
|
566 | * ```
|
567 | *
|
568 | * @param n A numeric value.
|
569 | * @param [base] The base of n.
|
570 | */
|
571 | dividedBy(n: BigNumber.Value, base?: number): BigNumber;
|
572 |
|
573 | /**
|
574 | * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded
|
575 | * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
|
576 | *
|
577 | * ```ts
|
578 | * x = new BigNumber(355)
|
579 | * y = new BigNumber(113)
|
580 | * x.div(y) // '3.14159292035398230088'
|
581 | * x.div(5) // '71'
|
582 | * x.div(47, 16) // '5'
|
583 | * ```
|
584 | *
|
585 | * @param n A numeric value.
|
586 | * @param [base] The base of n.
|
587 | */
|
588 | div(n: BigNumber.Value, base?: number): BigNumber;
|
589 |
|
590 | /**
|
591 | * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
|
592 | * `n`.
|
593 | *
|
594 | * ```ts
|
595 | * x = new BigNumber(5)
|
596 | * y = new BigNumber(3)
|
597 | * x.dividedToIntegerBy(y) // '1'
|
598 | * x.dividedToIntegerBy(0.7) // '7'
|
599 | * x.dividedToIntegerBy('0.f', 16) // '5'
|
600 | * ```
|
601 | *
|
602 | * @param n A numeric value.
|
603 | * @param [base] The base of n.
|
604 | */
|
605 | dividedToIntegerBy(n: BigNumber.Value, base?: number): BigNumber;
|
606 |
|
607 | /**
|
608 | * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
|
609 | * `n`.
|
610 | *
|
611 | * ```ts
|
612 | * x = new BigNumber(5)
|
613 | * y = new BigNumber(3)
|
614 | * x.idiv(y) // '1'
|
615 | * x.idiv(0.7) // '7'
|
616 | * x.idiv('0.f', 16) // '5'
|
617 | * ```
|
618 | *
|
619 | * @param n A numeric value.
|
620 | * @param [base] The base of n.
|
621 | */
|
622 | idiv(n: BigNumber.Value, base?: number): BigNumber;
|
623 |
|
624 | /**
|
625 | * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e.
|
626 | * raised to the power `n`, and optionally modulo a modulus `m`.
|
627 | *
|
628 | * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and
|
629 | * `ROUNDING_MODE` settings.
|
630 | *
|
631 | * As the number of digits of the result of the power operation can grow so large so quickly,
|
632 | * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is
|
633 | * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified).
|
634 | *
|
635 | * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant
|
636 | * digits will be calculated, and that the method's performance will decrease dramatically for
|
637 | * larger exponents.
|
638 | *
|
639 | * If `m` is specified and the value of `m`, `n` and this BigNumber are integers and `n` is
|
640 | * positive, then a fast modular exponentiation algorithm is used, otherwise the operation will
|
641 | * be performed as `x.exponentiatedBy(n).modulo(m)` with a `POW_PRECISION` of 0.
|
642 | *
|
643 | * Throws if `n` is not an integer.
|
644 | *
|
645 | * ```ts
|
646 | * Math.pow(0.7, 2) // 0.48999999999999994
|
647 | * x = new BigNumber(0.7)
|
648 | * x.exponentiatedBy(2) // '0.49'
|
649 | * BigNumber(3).exponentiatedBy(-2) // '0.11111111111111111111'
|
650 | * ```
|
651 | *
|
652 | * @param n The exponent, an integer.
|
653 | * @param [m] The modulus.
|
654 | */
|
655 | exponentiatedBy(n: BigNumber.Value, m?: BigNumber.Value): BigNumber;
|
656 | exponentiatedBy(n: number, m?: BigNumber.Value): BigNumber;
|
657 |
|
658 | /**
|
659 | * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e.
|
660 | * raised to the power `n`, and optionally modulo a modulus `m`.
|
661 | *
|
662 | * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and
|
663 | * `ROUNDING_MODE` settings.
|
664 | *
|
665 | * As the number of digits of the result of the power operation can grow so large so quickly,
|
666 | * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is
|
667 | * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified).
|
668 | *
|
669 | * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant
|
670 | * digits will be calculated, and that the method's performance will decrease dramatically for
|
671 | * larger exponents.
|
672 | *
|
673 | * If `m` is specified and the value of `m`, `n` and this BigNumber are integers and `n` is
|
674 | * positive, then a fast modular exponentiation algorithm is used, otherwise the operation will
|
675 | * be performed as `x.pow(n).modulo(m)` with a `POW_PRECISION` of 0.
|
676 | *
|
677 | * Throws if `n` is not an integer.
|
678 | *
|
679 | * ```ts
|
680 | * Math.pow(0.7, 2) // 0.48999999999999994
|
681 | * x = new BigNumber(0.7)
|
682 | * x.pow(2) // '0.49'
|
683 | * BigNumber(3).pow(-2) // '0.11111111111111111111'
|
684 | * ```
|
685 | *
|
686 | * @param n The exponent, an integer.
|
687 | * @param [m] The modulus.
|
688 | */
|
689 | pow(n: BigNumber.Value, m?: BigNumber.Value): BigNumber;
|
690 | pow(n: number, m?: BigNumber.Value): BigNumber;
|
691 |
|
692 | /**
|
693 | * Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using
|
694 | * rounding mode `rm`.
|
695 | *
|
696 | * If `rm` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
697 | *
|
698 | * Throws if `rm` is invalid.
|
699 | *
|
700 | * ```ts
|
701 | * x = new BigNumber(123.456)
|
702 | * x.integerValue() // '123'
|
703 | * x.integerValue(BigNumber.ROUND_CEIL) // '124'
|
704 | * y = new BigNumber(-12.7)
|
705 | * y.integerValue() // '-13'
|
706 | * x.integerValue(BigNumber.ROUND_DOWN) // '-12'
|
707 | * ```
|
708 | *
|
709 | * @param {BigNumber.RoundingMode} [rm] The roundng mode, an integer, 0 to 8.
|
710 | */
|
711 | integerValue(rm?: BigNumber.RoundingMode): BigNumber;
|
712 |
|
713 | /**
|
714 | * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns
|
715 | * `false`.
|
716 | *
|
717 | * As with JavaScript, `NaN` does not equal `NaN`.
|
718 | *
|
719 | * ```ts
|
720 | * 0 === 1e-324 // true
|
721 | * x = new BigNumber(0)
|
722 | * x.isEqualTo('1e-324') // false
|
723 | * BigNumber(-0).isEqualTo(x) // true ( -0 === 0 )
|
724 | * BigNumber(255).isEqualTo('ff', 16) // true
|
725 | *
|
726 | * y = new BigNumber(NaN)
|
727 | * y.isEqualTo(NaN) // false
|
728 | * ```
|
729 | *
|
730 | * @param n A numeric value.
|
731 | * @param [base] The base of n.
|
732 | */
|
733 | isEqualTo(n: BigNumber.Value, base?: number): boolean;
|
734 |
|
735 | /**
|
736 | * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns
|
737 | * `false`.
|
738 | *
|
739 | * As with JavaScript, `NaN` does not equal `NaN`.
|
740 | *
|
741 | * ```ts
|
742 | * 0 === 1e-324 // true
|
743 | * x = new BigNumber(0)
|
744 | * x.eq('1e-324') // false
|
745 | * BigNumber(-0).eq(x) // true ( -0 === 0 )
|
746 | * BigNumber(255).eq('ff', 16) // true
|
747 | *
|
748 | * y = new BigNumber(NaN)
|
749 | * y.eq(NaN) // false
|
750 | * ```
|
751 | *
|
752 | * @param n A numeric value.
|
753 | * @param [base] The base of n.
|
754 | */
|
755 | eq(n: BigNumber.Value, base?: number): boolean;
|
756 |
|
757 | /**
|
758 | * Returns `true` if the value of this BigNumber is a finite number, otherwise returns `false`.
|
759 | *
|
760 | * The only possible non-finite values of a BigNumber are `NaN`, `Infinity` and `-Infinity`.
|
761 | *
|
762 | * ```ts
|
763 | * x = new BigNumber(1)
|
764 | * x.isFinite() // true
|
765 | * y = new BigNumber(Infinity)
|
766 | * y.isFinite() // false
|
767 | * ```
|
768 | */
|
769 | isFinite(): boolean;
|
770 |
|
771 | /**
|
772 | * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise
|
773 | * returns `false`.
|
774 | *
|
775 | * ```ts
|
776 | * 0.1 > (0.3 - 0.2) // true
|
777 | * x = new BigNumber(0.1)
|
778 | * x.isGreaterThan(BigNumber(0.3).minus(0.2)) // false
|
779 | * BigNumber(0).isGreaterThan(x) // false
|
780 | * BigNumber(11, 3).isGreaterThan(11.1, 2) // true
|
781 | * ```
|
782 | *
|
783 | * @param n A numeric value.
|
784 | * @param [base] The base of n.
|
785 | */
|
786 | isGreaterThan(n: BigNumber.Value, base?: number): boolean;
|
787 |
|
788 | /**
|
789 | * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise
|
790 | * returns `false`.
|
791 | *
|
792 | * ```ts
|
793 | * 0.1 > (0.3 - 0 // true
|
794 | * x = new BigNumber(0.1)
|
795 | * x.gt(BigNumber(0.3).minus(0.2)) // false
|
796 | * BigNumber(0).gt(x) // false
|
797 | * BigNumber(11, 3).gt(11.1, 2) // true
|
798 | * ```
|
799 | *
|
800 | * @param n A numeric value.
|
801 | * @param [base] The base of n.
|
802 | */
|
803 | gt(n: BigNumber.Value, base?: number): boolean;
|
804 |
|
805 | /**
|
806 | * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`,
|
807 | * otherwise returns `false`.
|
808 | *
|
809 | * ```ts
|
810 | * (0.3 - 0.2) >= 0.1 // false
|
811 | * x = new BigNumber(0.3).minus(0.2)
|
812 | * x.isGreaterThanOrEqualTo(0.1) // true
|
813 | * BigNumber(1).isGreaterThanOrEqualTo(x) // true
|
814 | * BigNumber(10, 18).isGreaterThanOrEqualTo('i', 36) // true
|
815 | * ```
|
816 | *
|
817 | * @param n A numeric value.
|
818 | * @param [base] The base of n.
|
819 | */
|
820 | isGreaterThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;
|
821 |
|
822 | /**
|
823 | * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`,
|
824 | * otherwise returns `false`.
|
825 | *
|
826 | * ```ts
|
827 | * (0.3 - 0.2) >= 0.1 // false
|
828 | * x = new BigNumber(0.3).minus(0.2)
|
829 | * x.gte(0.1) // true
|
830 | * BigNumber(1).gte(x) // true
|
831 | * BigNumber(10, 18).gte('i', 36) // true
|
832 | * ```
|
833 | *
|
834 | * @param n A numeric value.
|
835 | * @param [base] The base of n.
|
836 | */
|
837 | gte(n: BigNumber.Value, base?: number): boolean;
|
838 |
|
839 | /**
|
840 | * Returns `true` if the value of this BigNumber is an integer, otherwise returns `false`.
|
841 | *
|
842 | * ```ts
|
843 | * x = new BigNumber(1)
|
844 | * x.isInteger() // true
|
845 | * y = new BigNumber(123.456)
|
846 | * y.isInteger() // false
|
847 | * ```
|
848 | */
|
849 | isInteger(): boolean;
|
850 |
|
851 | /**
|
852 | * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns
|
853 | * `false`.
|
854 | *
|
855 | * ```ts
|
856 | * (0.3 - 0.2) < 0.1 // true
|
857 | * x = new BigNumber(0.3).minus(0.2)
|
858 | * x.isLessThan(0.1) // false
|
859 | * BigNumber(0).isLessThan(x) // true
|
860 | * BigNumber(11.1, 2).isLessThan(11, 3) // true
|
861 | * ```
|
862 | *
|
863 | * @param n A numeric value.
|
864 | * @param [base] The base of n.
|
865 | */
|
866 | isLessThan(n: BigNumber.Value, base?: number): boolean;
|
867 |
|
868 | /**
|
869 | * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns
|
870 | * `false`.
|
871 | *
|
872 | * ```ts
|
873 | * (0.3 - 0.2) < 0.1 // true
|
874 | * x = new BigNumber(0.3).minus(0.2)
|
875 | * x.lt(0.1) // false
|
876 | * BigNumber(0).lt(x) // true
|
877 | * BigNumber(11.1, 2).lt(11, 3) // true
|
878 | * ```
|
879 | *
|
880 | * @param n A numeric value.
|
881 | * @param [base] The base of n.
|
882 | */
|
883 | lt(n: BigNumber.Value, base?: number): boolean;
|
884 |
|
885 | /**
|
886 | * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`,
|
887 | * otherwise returns `false`.
|
888 | *
|
889 | * ```ts
|
890 | * 0.1 <= (0.3 - 0.2) // false
|
891 | * x = new BigNumber(0.1)
|
892 | * x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2)) // true
|
893 | * BigNumber(-1).isLessThanOrEqualTo(x) // true
|
894 | * BigNumber(10, 18).isLessThanOrEqualTo('i', 36) // true
|
895 | * ```
|
896 | *
|
897 | * @param n A numeric value.
|
898 | * @param [base] The base of n.
|
899 | */
|
900 | isLessThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;
|
901 |
|
902 | /**
|
903 | * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`,
|
904 | * otherwise returns `false`.
|
905 | *
|
906 | * ```ts
|
907 | * 0.1 <= (0.3 - 0.2) // false
|
908 | * x = new BigNumber(0.1)
|
909 | * x.lte(BigNumber(0.3).minus(0.2)) // true
|
910 | * BigNumber(-1).lte(x) // true
|
911 | * BigNumber(10, 18).lte('i', 36) // true
|
912 | * ```
|
913 | *
|
914 | * @param n A numeric value.
|
915 | * @param [base] The base of n.
|
916 | */
|
917 | lte(n: BigNumber.Value, base?: number): boolean;
|
918 |
|
919 | /**
|
920 | * Returns `true` if the value of this BigNumber is `NaN`, otherwise returns `false`.
|
921 | *
|
922 | * ```ts
|
923 | * x = new BigNumber(NaN)
|
924 | * x.isNaN() // true
|
925 | * y = new BigNumber('Infinity')
|
926 | * y.isNaN() // false
|
927 | * ```
|
928 | */
|
929 | isNaN(): boolean;
|
930 |
|
931 | /**
|
932 | * Returns `true` if the value of this BigNumber is negative, otherwise returns `false`.
|
933 | *
|
934 | * ```ts
|
935 | * x = new BigNumber(-0)
|
936 | * x.isNegative() // true
|
937 | * y = new BigNumber(2)
|
938 | * y.isNegative() // false
|
939 | * ```
|
940 | */
|
941 | isNegative(): boolean;
|
942 |
|
943 | /**
|
944 | * Returns `true` if the value of this BigNumber is positive, otherwise returns `false`.
|
945 | *
|
946 | * ```ts
|
947 | * x = new BigNumber(-0)
|
948 | * x.isPositive() // false
|
949 | * y = new BigNumber(2)
|
950 | * y.isPositive() // true
|
951 | * ```
|
952 | */
|
953 | isPositive(): boolean;
|
954 |
|
955 | /**
|
956 | * Returns `true` if the value of this BigNumber is zero or minus zero, otherwise returns `false`.
|
957 | *
|
958 | * ```ts
|
959 | * x = new BigNumber(-0)
|
960 | * x.isZero() // true
|
961 | * ```
|
962 | */
|
963 | isZero(): boolean;
|
964 |
|
965 | /**
|
966 | * Returns a BigNumber whose value is the value of this BigNumber minus `n`.
|
967 | *
|
968 | * The return value is always exact and unrounded.
|
969 | *
|
970 | * ```ts
|
971 | * 0.3 - 0.1 // 0.19999999999999998
|
972 | * x = new BigNumber(0.3)
|
973 | * x.minus(0.1) // '0.2'
|
974 | * x.minus(0.6, 20) // '0'
|
975 | * ```
|
976 | *
|
977 | * @param n A numeric value.
|
978 | * @param [base] The base of n.
|
979 | */
|
980 | minus(n: BigNumber.Value, base?: number): BigNumber;
|
981 |
|
982 | /**
|
983 | * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer
|
984 | * remainder of dividing this BigNumber by `n`.
|
985 | *
|
986 | * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE`
|
987 | * setting of this BigNumber constructor. If it is 1 (default value), the result will have the
|
988 | * same sign as this BigNumber, and it will match that of Javascript's `%` operator (within the
|
989 | * limits of double precision) and BigDecimal's `remainder` method.
|
990 | *
|
991 | * The return value is always exact and unrounded.
|
992 | *
|
993 | * See `MODULO_MODE` for a description of the other modulo modes.
|
994 | *
|
995 | * ```ts
|
996 | * 1 % 0.9 // 0.09999999999999998
|
997 | * x = new BigNumber(1)
|
998 | * x.modulo(0.9) // '0.1'
|
999 | * y = new BigNumber(33)
|
1000 | * y.modulo('a', 33) // '3'
|
1001 | * ```
|
1002 | *
|
1003 | * @param n A numeric value.
|
1004 | * @param [base] The base of n.
|
1005 | */
|
1006 | modulo(n: BigNumber.Value, base?: number): BigNumber;
|
1007 |
|
1008 | /**
|
1009 | * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer
|
1010 | * remainder of dividing this BigNumber by `n`.
|
1011 | *
|
1012 | * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE`
|
1013 | * setting of this BigNumber constructor. If it is 1 (default value), the result will have the
|
1014 | * same sign as this BigNumber, and it will match that of Javascript's `%` operator (within the
|
1015 | * limits of double precision) and BigDecimal's `remainder` method.
|
1016 | *
|
1017 | * The return value is always exact and unrounded.
|
1018 | *
|
1019 | * See `MODULO_MODE` for a description of the other modulo modes.
|
1020 | *
|
1021 | * ```ts
|
1022 | * 1 % 0.9 // 0.09999999999999998
|
1023 | * x = new BigNumber(1)
|
1024 | * x.mod(0.9) // '0.1'
|
1025 | * y = new BigNumber(33)
|
1026 | * y.mod('a', 33) // '3'
|
1027 | * ```
|
1028 | *
|
1029 | * @param n A numeric value.
|
1030 | * @param [base] The base of n.
|
1031 | */
|
1032 | mod(n: BigNumber.Value, base?: number): BigNumber;
|
1033 |
|
1034 | /**
|
1035 | * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`.
|
1036 | *
|
1037 | * The return value is always exact and unrounded.
|
1038 | *
|
1039 | * ```ts
|
1040 | * 0.6 * 3 // 1.7999999999999998
|
1041 | * x = new BigNumber(0.6)
|
1042 | * y = x.multipliedBy(3) // '1.8'
|
1043 | * BigNumber('7e+500').multipliedBy(y) // '1.26e+501'
|
1044 | * x.multipliedBy('-a', 16) // '-6'
|
1045 | * ```
|
1046 | *
|
1047 | * @param n A numeric value.
|
1048 | * @param [base] The base of n.
|
1049 | */
|
1050 | multipliedBy(n: BigNumber.Value, base?: number): BigNumber;
|
1051 |
|
1052 | /**
|
1053 | * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`.
|
1054 | *
|
1055 | * The return value is always exact and unrounded.
|
1056 | *
|
1057 | * ```ts
|
1058 | * 0.6 * 3 // 1.7999999999999998
|
1059 | * x = new BigNumber(0.6)
|
1060 | * y = x.times(3) // '1.8'
|
1061 | * BigNumber('7e+500').times(y) // '1.26e+501'
|
1062 | * x.times('-a', 16) // '-6'
|
1063 | * ```
|
1064 | *
|
1065 | * @param n A numeric value.
|
1066 | * @param [base] The base of n.
|
1067 | */
|
1068 | times(n: BigNumber.Value, base?: number): BigNumber;
|
1069 |
|
1070 | /**
|
1071 | * Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by -1.
|
1072 | *
|
1073 | * ```ts
|
1074 | * x = new BigNumber(1.8)
|
1075 | * x.negated() // '-1.8'
|
1076 | * y = new BigNumber(-1.3)
|
1077 | * y.negated() // '1.3'
|
1078 | * ```
|
1079 | */
|
1080 | negated(): BigNumber;
|
1081 |
|
1082 | /**
|
1083 | * Returns a BigNumber whose value is the value of this BigNumber plus `n`.
|
1084 | *
|
1085 | * The return value is always exact and unrounded.
|
1086 | *
|
1087 | * ```ts
|
1088 | * 0.1 + 0.2 // 0.30000000000000004
|
1089 | * x = new BigNumber(0.1)
|
1090 | * y = x.plus(0.2) // '0.3'
|
1091 | * BigNumber(0.7).plus(x).plus(y) // '1.1'
|
1092 | * x.plus('0.1', 8) // '0.225'
|
1093 | * ```
|
1094 | *
|
1095 | * @param n A numeric value.
|
1096 | * @param [base] The base of n.
|
1097 | */
|
1098 | plus(n: BigNumber.Value, base?: number): BigNumber;
|
1099 |
|
1100 | /**
|
1101 | * Returns the number of significant digits of the value of this BigNumber, or `null` if the value
|
1102 | * of this BigNumber is ±`Infinity` or `NaN`.
|
1103 | *
|
1104 | * If `includeZeros` is true then any trailing zeros of the integer part of the value of this
|
1105 | * BigNumber are counted as significant digits, otherwise they are not.
|
1106 | *
|
1107 | * Throws if `includeZeros` is invalid.
|
1108 | *
|
1109 | * ```ts
|
1110 | * x = new BigNumber(9876.54321)
|
1111 | * x.precision() // 9
|
1112 | * y = new BigNumber(987000)
|
1113 | * y.precision(false) // 3
|
1114 | * y.precision(true) // 6
|
1115 | * ```
|
1116 | *
|
1117 | * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count.
|
1118 | */
|
1119 | precision(includeZeros?: boolean): number;
|
1120 |
|
1121 | /**
|
1122 | * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of
|
1123 | * `significantDigits` significant digits using rounding mode `roundingMode`.
|
1124 | *
|
1125 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used.
|
1126 | *
|
1127 | * Throws if `significantDigits` or `roundingMode` is invalid.
|
1128 | *
|
1129 | * ```ts
|
1130 | * x = new BigNumber(9876.54321)
|
1131 | * x.precision(6) // '9876.54'
|
1132 | * x.precision(6, BigNumber.ROUND_UP) // '9876.55'
|
1133 | * x.precision(2) // '9900'
|
1134 | * x.precision(2, 1) // '9800'
|
1135 | * x // '9876.54321'
|
1136 | * ```
|
1137 | *
|
1138 | * @param significantDigits Significant digits, integer, 1 to 1e+9.
|
1139 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
1140 | */
|
1141 | precision(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
|
1142 |
|
1143 | /**
|
1144 | * Returns the number of significant digits of the value of this BigNumber,
|
1145 | * or `null` if the value of this BigNumber is ±`Infinity` or `NaN`.
|
1146 | *
|
1147 | * If `includeZeros` is true then any trailing zeros of the integer part of
|
1148 | * the value of this BigNumber are counted as significant digits, otherwise
|
1149 | * they are not.
|
1150 | *
|
1151 | * Throws if `includeZeros` is invalid.
|
1152 | *
|
1153 | * ```ts
|
1154 | * x = new BigNumber(9876.54321)
|
1155 | * x.sd() // 9
|
1156 | * y = new BigNumber(987000)
|
1157 | * y.sd(false) // 3
|
1158 | * y.sd(true) // 6
|
1159 | * ```
|
1160 | *
|
1161 | * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count.
|
1162 | */
|
1163 | sd(includeZeros?: boolean): number;
|
1164 |
|
1165 | /**
|
1166 | * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of
|
1167 | * `significantDigits` significant digits using rounding mode `roundingMode`.
|
1168 | *
|
1169 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used.
|
1170 | *
|
1171 | * Throws if `significantDigits` or `roundingMode` is invalid.
|
1172 | *
|
1173 | * ```ts
|
1174 | * x = new BigNumber(9876.54321)
|
1175 | * x.sd(6) // '9876.54'
|
1176 | * x.sd(6, BigNumber.ROUND_UP) // '9876.55'
|
1177 | * x.sd(2) // '9900'
|
1178 | * x.sd(2, 1) // '9800'
|
1179 | * x // '9876.54321'
|
1180 | * ```
|
1181 | *
|
1182 | * @param significantDigits Significant digits, integer, 1 to 1e+9.
|
1183 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
1184 | */
|
1185 | sd(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
|
1186 |
|
1187 | /**
|
1188 | * Returns a BigNumber whose value is the value of this BigNumber shifted by `n` places.
|
1189 | *
|
1190 | * The shift is of the decimal point, i.e. of powers of ten, and is to the left if `n` is negative
|
1191 | * or to the right if `n` is positive.
|
1192 | *
|
1193 | * The return value is always exact and unrounded.
|
1194 | *
|
1195 | * Throws if `n` is invalid.
|
1196 | *
|
1197 | * ```ts
|
1198 | * x = new BigNumber(1.23)
|
1199 | * x.shiftedBy(3) // '1230'
|
1200 | * x.shiftedBy(-3) // '0.00123'
|
1201 | * ```
|
1202 | *
|
1203 | * @param n The shift value, integer, -9007199254740991 to 9007199254740991.
|
1204 | */
|
1205 | shiftedBy(n: number): BigNumber;
|
1206 |
|
1207 | /**
|
1208 | * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded
|
1209 | * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
|
1210 | *
|
1211 | * The return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
1212 | * to an infinite number of correct digits before rounding.
|
1213 | *
|
1214 | * ```ts
|
1215 | * x = new BigNumber(16)
|
1216 | * x.squareRoot() // '4'
|
1217 | * y = new BigNumber(3)
|
1218 | * y.squareRoot() // '1.73205080756887729353'
|
1219 | * ```
|
1220 | */
|
1221 | squareRoot(): BigNumber;
|
1222 |
|
1223 | /**
|
1224 | * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded
|
1225 | * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
|
1226 | *
|
1227 | * The return value will be correctly rounded, i.e. rounded as if the result was first calculated
|
1228 | * to an infinite number of correct digits before rounding.
|
1229 | *
|
1230 | * ```ts
|
1231 | * x = new BigNumber(16)
|
1232 | * x.sqrt() // '4'
|
1233 | * y = new BigNumber(3)
|
1234 | * y.sqrt() // '1.73205080756887729353'
|
1235 | * ```
|
1236 | */
|
1237 | sqrt(): BigNumber;
|
1238 |
|
1239 | /**
|
1240 | * Returns a string representing the value of this BigNumber in exponential notation rounded using
|
1241 | * rounding mode `roundingMode` to `decimalPlaces` decimal places, i.e with one digit before the
|
1242 | * decimal point and `decimalPlaces` digits after it.
|
1243 | *
|
1244 | * If the value of this BigNumber in exponential notation has fewer than `decimalPlaces` fraction
|
1245 | * digits, the return value will be appended with zeros accordingly.
|
1246 | *
|
1247 | * If `decimalPlaces` is omitted, or is `null` or `undefined`, the number of digits after the
|
1248 | * decimal point defaults to the minimum number of digits necessary to represent the value
|
1249 | * exactly.
|
1250 | *
|
1251 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
1252 | *
|
1253 | * Throws if `decimalPlaces` or `roundingMode` is invalid.
|
1254 | *
|
1255 | * ```ts
|
1256 | * x = 45.6
|
1257 | * y = new BigNumber(x)
|
1258 | * x.toExponential() // '4.56e+1'
|
1259 | * y.toExponential() // '4.56e+1'
|
1260 | * x.toExponential(0) // '5e+1'
|
1261 | * y.toExponential(0) // '5e+1'
|
1262 | * x.toExponential(1) // '4.6e+1'
|
1263 | * y.toExponential(1) // '4.6e+1'
|
1264 | * y.toExponential(1, 1) // '4.5e+1' (ROUND_DOWN)
|
1265 | * x.toExponential(3) // '4.560e+1'
|
1266 | * y.toExponential(3) // '4.560e+1'
|
1267 | * ```
|
1268 | *
|
1269 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
1270 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
1271 | */
|
1272 | toExponential(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;
|
1273 | toExponential(): string;
|
1274 |
|
1275 | /**
|
1276 | * Returns a string representing the value of this BigNumber in normal (fixed-point) notation
|
1277 | * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`.
|
1278 | *
|
1279 | * If the value of this BigNumber in normal notation has fewer than `decimalPlaces` fraction
|
1280 | * digits, the return value will be appended with zeros accordingly.
|
1281 | *
|
1282 | * Unlike `Number.prototype.toFixed`, which returns exponential notation if a number is greater or
|
1283 | * equal to 10**21, this method will always return normal notation.
|
1284 | *
|
1285 | * If `decimalPlaces` is omitted or is `null` or `undefined`, the return value will be unrounded
|
1286 | * and in normal notation. This is also unlike `Number.prototype.toFixed`, which returns the value
|
1287 | * to zero decimal places. It is useful when normal notation is required and the current
|
1288 | * `EXPONENTIAL_AT` setting causes `toString` to return exponential notation.
|
1289 | *
|
1290 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
1291 | *
|
1292 | * Throws if `decimalPlaces` or `roundingMode` is invalid.
|
1293 | *
|
1294 | * ```ts
|
1295 | * x = 3.456
|
1296 | * y = new BigNumber(x)
|
1297 | * x.toFixed() // '3'
|
1298 | * y.toFixed() // '3.456'
|
1299 | * y.toFixed(0) // '3'
|
1300 | * x.toFixed(2) // '3.46'
|
1301 | * y.toFixed(2) // '3.46'
|
1302 | * y.toFixed(2, 1) // '3.45' (ROUND_DOWN)
|
1303 | * x.toFixed(5) // '3.45600'
|
1304 | * y.toFixed(5) // '3.45600'
|
1305 | * ```
|
1306 | *
|
1307 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
1308 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
1309 | */
|
1310 | toFixed(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;
|
1311 | toFixed(): string;
|
1312 |
|
1313 | /**
|
1314 | * Returns a string representing the value of this BigNumber in normal (fixed-point) notation
|
1315 | * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`, and formatted
|
1316 | * according to the properties of the `format` or `FORMAT` object.
|
1317 | *
|
1318 | * The formatting object may contain some or all of the properties shown in the examples below.
|
1319 | *
|
1320 | * If `decimalPlaces` is omitted or is `null` or `undefined`, then the return value is not
|
1321 | * rounded to a fixed number of decimal places.
|
1322 | *
|
1323 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
1324 | *
|
1325 | * If `format` is omitted or is `null` or `undefined`, `FORMAT` is used.
|
1326 | *
|
1327 | * Throws if `decimalPlaces`, `roundingMode`, or `format` is invalid.
|
1328 | *
|
1329 | * ```ts
|
1330 | * fmt = {
|
1331 | * decimalSeparator: '.',
|
1332 | * groupSeparator: ',',
|
1333 | * groupSize: 3,
|
1334 | * secondaryGroupSize: 0,
|
1335 | * fractionGroupSeparator: ' ',
|
1336 | * fractionGroupSize: 0
|
1337 | * }
|
1338 | *
|
1339 | * x = new BigNumber('123456789.123456789')
|
1340 | *
|
1341 | * // Set the global formatting options
|
1342 | * BigNumber.config({ FORMAT: fmt })
|
1343 | *
|
1344 | * x.toFormat() // '123,456,789.123456789'
|
1345 | * x.toFormat(3) // '123,456,789.123'
|
1346 | *
|
1347 | * // If a reference to the object assigned to FORMAT has been retained,
|
1348 | * // the format properties can be changed directly
|
1349 | * fmt.groupSeparator = ' '
|
1350 | * fmt.fractionGroupSize = 5
|
1351 | * x.toFormat() // '123 456 789.12345 6789'
|
1352 | *
|
1353 | * // Alternatively, pass the formatting options as an argument
|
1354 | * fmt = {
|
1355 | * decimalSeparator: ',',
|
1356 | * groupSeparator: '.',
|
1357 | * groupSize: 3,
|
1358 | * secondaryGroupSize: 2
|
1359 | * }
|
1360 | *
|
1361 | * x.toFormat() // '123 456 789.12345 6789'
|
1362 | * x.toFormat(fmt) // '12.34.56.789,123456789'
|
1363 | * x.toFormat(2, fmt) // '12.34.56.789,12'
|
1364 | * x.toFormat(3, BigNumber.ROUND_UP, fmt) // '12.34.56.789,124'
|
1365 | * ```
|
1366 | *
|
1367 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
1368 | * @param [roundingMode] Rounding mode, integer, 0 to 8.
|
1369 | * @param [format] Formatting options object. See `BigNumber.Format`.
|
1370 | */
|
1371 | toFormat(decimalPlaces: number, roundingMode: BigNumber.RoundingMode, format?: BigNumber.Format): string;
|
1372 | toFormat(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;
|
1373 | toFormat(decimalPlaces?: number): string;
|
1374 | toFormat(decimalPlaces: number, format: BigNumber.Format): string;
|
1375 | toFormat(format: BigNumber.Format): string;
|
1376 |
|
1377 | /**
|
1378 | * Returns an array of two BigNumbers representing the value of this BigNumber as a simple
|
1379 | * fraction with an integer numerator and an integer denominator.
|
1380 | * The denominator will be a positive non-zero value less than or equal to `max_denominator`.
|
1381 | * If a maximum denominator, `max_denominator`, is not specified, or is `null` or `undefined`, the
|
1382 | * denominator will be the lowest value necessary to represent the number exactly.
|
1383 | *
|
1384 | * Throws if `max_denominator` is invalid.
|
1385 | *
|
1386 | * ```ts
|
1387 | * x = new BigNumber(1.75)
|
1388 | * x.toFraction() // '7, 4'
|
1389 | *
|
1390 | * pi = new BigNumber('3.14159265358')
|
1391 | * pi.toFraction() // '157079632679,50000000000'
|
1392 | * pi.toFraction(100000) // '312689, 99532'
|
1393 | * pi.toFraction(10000) // '355, 113'
|
1394 | * pi.toFraction(100) // '311, 99'
|
1395 | * pi.toFraction(10) // '22, 7'
|
1396 | * pi.toFraction(1) // '3, 1'
|
1397 | * ```
|
1398 | *
|
1399 | * @param [max_denominator] The maximum denominator, integer > 0, or Infinity.
|
1400 | */
|
1401 | toFraction(max_denominator?: BigNumber.Value): [BigNumber, BigNumber];
|
1402 |
|
1403 | /** As `valueOf`. */
|
1404 | toJSON(): string;
|
1405 |
|
1406 | /**
|
1407 | * Returns the value of this BigNumber as a JavaScript primitive number.
|
1408 | *
|
1409 | * Using the unary plus operator gives the same result.
|
1410 | *
|
1411 | * ```ts
|
1412 | * x = new BigNumber(456.789)
|
1413 | * x.toNumber() // 456.789
|
1414 | * +x // 456.789
|
1415 | *
|
1416 | * y = new BigNumber('45987349857634085409857349856430985')
|
1417 | * y.toNumber() // 4.598734985763409e+34
|
1418 | *
|
1419 | * z = new BigNumber(-0)
|
1420 | * 1 / z.toNumber() // -Infinity
|
1421 | * 1 / +z // -Infinity
|
1422 | * ```
|
1423 | */
|
1424 | toNumber(): number;
|
1425 |
|
1426 | /**
|
1427 | * Returns a string representing the value of this BigNumber rounded to `significantDigits`
|
1428 | * significant digits using rounding mode `roundingMode`.
|
1429 | *
|
1430 | * If `significantDigits` is less than the number of digits necessary to represent the integer
|
1431 | * part of the value in normal (fixed-point) notation, then exponential notation is used.
|
1432 | *
|
1433 | * If `significantDigits` is omitted, or is `null` or `undefined`, then the return value is the
|
1434 | * same as `n.toString()`.
|
1435 | *
|
1436 | * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
|
1437 | *
|
1438 | * Throws if `significantDigits` or `roundingMode` is invalid.
|
1439 | *
|
1440 | * ```ts
|
1441 | * x = 45.6
|
1442 | * y = new BigNumber(x)
|
1443 | * x.toPrecision() // '45.6'
|
1444 | * y.toPrecision() // '45.6'
|
1445 | * x.toPrecision(1) // '5e+1'
|
1446 | * y.toPrecision(1) // '5e+1'
|
1447 | * y.toPrecision(2, 0) // '4.6e+1' (ROUND_UP)
|
1448 | * y.toPrecision(2, 1) // '4.5e+1' (ROUND_DOWN)
|
1449 | * x.toPrecision(5) // '45.600'
|
1450 | * y.toPrecision(5) // '45.600'
|
1451 | * ```
|
1452 | *
|
1453 | * @param [significantDigits] Significant digits, integer, 1 to 1e+9.
|
1454 | * @param [roundingMode] Rounding mode, integer 0 to 8.
|
1455 | */
|
1456 | toPrecision(significantDigits: number, roundingMode?: BigNumber.RoundingMode): string;
|
1457 | toPrecision(): string;
|
1458 |
|
1459 | /**
|
1460 | * Returns a string representing the value of this BigNumber in base `base`, or base 10 if `base`
|
1461 | * is omitted or is `null` or `undefined`.
|
1462 | *
|
1463 | * For bases above 10, and using the default base conversion alphabet (see `ALPHABET`), values
|
1464 | * from 10 to 35 are represented by a-z (the same as `Number.prototype.toString`).
|
1465 | *
|
1466 | * If a base is specified the value is rounded according to the current `DECIMAL_PLACES` and
|
1467 | * `ROUNDING_MODE` settings, otherwise it is not.
|
1468 | *
|
1469 | * If a base is not specified, and this BigNumber has a positive exponent that is equal to or
|
1470 | * greater than the positive component of the current `EXPONENTIAL_AT` setting, or a negative
|
1471 | * exponent equal to or less than the negative component of the setting, then exponential notation
|
1472 | * is returned.
|
1473 | *
|
1474 | * If `base` is `null` or `undefined` it is ignored.
|
1475 | *
|
1476 | * Throws if `base` is invalid.
|
1477 | *
|
1478 | * ```ts
|
1479 | * x = new BigNumber(750000)
|
1480 | * x.toString() // '750000'
|
1481 | * BigNumber.config({ EXPONENTIAL_AT: 5 })
|
1482 | * x.toString() // '7.5e+5'
|
1483 | *
|
1484 | * y = new BigNumber(362.875)
|
1485 | * y.toString(2) // '101101010.111'
|
1486 | * y.toString(9) // '442.77777777777777777778'
|
1487 | * y.toString(32) // 'ba.s'
|
1488 | *
|
1489 | * BigNumber.config({ DECIMAL_PLACES: 4 });
|
1490 | * z = new BigNumber('1.23456789')
|
1491 | * z.toString() // '1.23456789'
|
1492 | * z.toString(10) // '1.2346'
|
1493 | * ```
|
1494 | *
|
1495 | * @param [base] The base, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`).
|
1496 | */
|
1497 | toString(base?: number): string;
|
1498 |
|
1499 | /**
|
1500 | * As `toString`, but does not accept a base argument and includes the minus sign for negative
|
1501 | * zero.
|
1502 | *
|
1503 | * ``ts
|
1504 | * x = new BigNumber('-0')
|
1505 | * x.toString() // '0'
|
1506 | * x.valueOf() // '-0'
|
1507 | * y = new BigNumber('1.777e+457')
|
1508 | * y.valueOf() // '1.777e+457'
|
1509 | * ```
|
1510 | */
|
1511 | valueOf(): string;
|
1512 |
|
1513 | /** Helps ES6 import. */
|
1514 | private static readonly default?: BigNumber.Constructor;
|
1515 |
|
1516 | /** Helps ES6 import. */
|
1517 | private static readonly BigNumber?: BigNumber.Constructor;
|
1518 |
|
1519 | /** Rounds away from zero. */
|
1520 | static readonly ROUND_UP: 0;
|
1521 |
|
1522 | /** Rounds towards zero. */
|
1523 | static readonly ROUND_DOWN: 1;
|
1524 |
|
1525 | /** Rounds towards Infinity. */
|
1526 | static readonly ROUND_CEIL: 2;
|
1527 |
|
1528 | /** Rounds towards -Infinity. */
|
1529 | static readonly ROUND_FLOOR: 3;
|
1530 |
|
1531 | /** Rounds towards nearest neighbour. If equidistant, rounds away from zero . */
|
1532 | static readonly ROUND_HALF_UP: 4;
|
1533 |
|
1534 | /** Rounds towards nearest neighbour. If equidistant, rounds towards zero. */
|
1535 | static readonly ROUND_HALF_DOWN: 5;
|
1536 |
|
1537 | /** Rounds towards nearest neighbour. If equidistant, rounds towards even neighbour. */
|
1538 | static readonly ROUND_HALF_EVEN: 6;
|
1539 |
|
1540 | /** Rounds towards nearest neighbour. If equidistant, rounds towards Infinity. */
|
1541 | static readonly ROUND_HALF_CEIL: 7;
|
1542 |
|
1543 | /** Rounds towards nearest neighbour. If equidistant, rounds towards -Infinity. */
|
1544 | static readonly ROUND_HALF_FLOOR: 8;
|
1545 |
|
1546 | /** See `MODULO_MODE`. */
|
1547 | static readonly EUCLID: 9;
|
1548 |
|
1549 | /**
|
1550 | * To aid in debugging, if a `BigNumber.DEBUG` property is `true` then an error will be thrown
|
1551 | * if the BigNumber constructor receives an invalid `BigNumber.Value`, or if `BigNumber.isBigNumber`
|
1552 | * receives a BigNumber instance that is malformed.
|
1553 | *
|
1554 | * ```ts
|
1555 | * // No error, and BigNumber NaN is returned.
|
1556 | * new BigNumber('blurgh') // 'NaN'
|
1557 | * new BigNumber(9, 2) // 'NaN'
|
1558 | * BigNumber.DEBUG = true
|
1559 | * new BigNumber('blurgh') // '[BigNumber Error] Not a number'
|
1560 | * new BigNumber(9, 2) // '[BigNumber Error] Not a base 2 number'
|
1561 | * ```
|
1562 | *
|
1563 | * An error will also be thrown if a `BigNumber.Value` is of type number with more than 15
|
1564 | * significant digits, as calling `toString` or `valueOf` on such numbers may not result
|
1565 | * in the intended value.
|
1566 | *
|
1567 | * ```ts
|
1568 | * console.log(823456789123456.3) // 823456789123456.2
|
1569 | * // No error, and the returned BigNumber does not have the same value as the number literal.
|
1570 | * new BigNumber(823456789123456.3) // '823456789123456.2'
|
1571 | * BigNumber.DEBUG = true
|
1572 | * new BigNumber(823456789123456.3)
|
1573 | * // '[BigNumber Error] Number primitive has more than 15 significant digits'
|
1574 | * ```
|
1575 | *
|
1576 | * Check that a BigNumber instance is well-formed:
|
1577 | *
|
1578 | * ```ts
|
1579 | * x = new BigNumber(10)
|
1580 | *
|
1581 | * BigNumber.DEBUG = false
|
1582 | * // Change x.c to an illegitimate value.
|
1583 | * x.c = NaN
|
1584 | * // No error, as BigNumber.DEBUG is false.
|
1585 | * BigNumber.isBigNumber(x) // true
|
1586 | *
|
1587 | * BigNumber.DEBUG = true
|
1588 | * BigNumber.isBigNumber(x) // '[BigNumber Error] Invalid BigNumber'
|
1589 | * ```
|
1590 | */
|
1591 | static DEBUG?: boolean;
|
1592 |
|
1593 | /**
|
1594 | * Returns a new independent BigNumber constructor with configuration as described by `object`, or
|
1595 | * with the default configuration if object is `null` or `undefined`.
|
1596 | *
|
1597 | * Throws if `object` is not an object.
|
1598 | *
|
1599 | * ```ts
|
1600 | * BigNumber.config({ DECIMAL_PLACES: 5 })
|
1601 | * BN = BigNumber.clone({ DECIMAL_PLACES: 9 })
|
1602 | *
|
1603 | * x = new BigNumber(1)
|
1604 | * y = new BN(1)
|
1605 | *
|
1606 | * x.div(3) // 0.33333
|
1607 | * y.div(3) // 0.333333333
|
1608 | *
|
1609 | * // BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) is equivalent to:
|
1610 | * BN = BigNumber.clone()
|
1611 | * BN.config({ DECIMAL_PLACES: 9 })
|
1612 | * ```
|
1613 | *
|
1614 | * @param [object] The configuration object.
|
1615 | */
|
1616 | static clone(object?: BigNumber.Config): BigNumber.Constructor;
|
1617 |
|
1618 | /**
|
1619 | * Configures the settings that apply to this BigNumber constructor.
|
1620 | *
|
1621 | * The configuration object, `object`, contains any number of the properties shown in the example
|
1622 | * below.
|
1623 | *
|
1624 | * Returns an object with the above properties and their current values.
|
1625 | *
|
1626 | * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the
|
1627 | * properties.
|
1628 | *
|
1629 | * ```ts
|
1630 | * BigNumber.config({
|
1631 | * DECIMAL_PLACES: 40,
|
1632 | * ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
|
1633 | * EXPONENTIAL_AT: [-10, 20],
|
1634 | * RANGE: [-500, 500],
|
1635 | * CRYPTO: true,
|
1636 | * MODULO_MODE: BigNumber.ROUND_FLOOR,
|
1637 | * POW_PRECISION: 80,
|
1638 | * FORMAT: {
|
1639 | * groupSize: 3,
|
1640 | * groupSeparator: ' ',
|
1641 | * decimalSeparator: ','
|
1642 | * },
|
1643 | * ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
|
1644 | * });
|
1645 | *
|
1646 | * BigNumber.config().DECIMAL_PLACES // 40
|
1647 | * ```
|
1648 | *
|
1649 | * @param object The configuration object.
|
1650 | */
|
1651 | static config(object?: BigNumber.Config): BigNumber.Config;
|
1652 |
|
1653 | /**
|
1654 | * Returns `true` if `value` is a BigNumber instance, otherwise returns `false`.
|
1655 | *
|
1656 | * If `BigNumber.DEBUG` is `true`, throws if a BigNumber instance is not well-formed.
|
1657 | *
|
1658 | * ```ts
|
1659 | * x = 42
|
1660 | * y = new BigNumber(x)
|
1661 | *
|
1662 | * BigNumber.isBigNumber(x) // false
|
1663 | * y instanceof BigNumber // true
|
1664 | * BigNumber.isBigNumber(y) // true
|
1665 | *
|
1666 | * BN = BigNumber.clone();
|
1667 | * z = new BN(x)
|
1668 | * z instanceof BigNumber // false
|
1669 | * BigNumber.isBigNumber(z) // true
|
1670 | * ```
|
1671 | *
|
1672 | * @param value The value to test.
|
1673 | */
|
1674 | static isBigNumber(value: any): value is BigNumber;
|
1675 |
|
1676 | /**
|
1677 | * Returns a BigNumber whose value is the maximum of the arguments.
|
1678 | *
|
1679 | * The return value is always exact and unrounded.
|
1680 | *
|
1681 | * ```ts
|
1682 | * x = new BigNumber('3257869345.0378653')
|
1683 | * BigNumber.maximum(4e9, x, '123456789.9') // '4000000000'
|
1684 | *
|
1685 | * arr = [12, '13', new BigNumber(14)]
|
1686 | * BigNumber.maximum.apply(null, arr) // '14'
|
1687 | * ```
|
1688 | *
|
1689 | * @param n A numeric value.
|
1690 | */
|
1691 | static maximum(...n: BigNumber.Value[]): BigNumber;
|
1692 |
|
1693 | /**
|
1694 | * Returns a BigNumber whose value is the maximum of the arguments.
|
1695 | *
|
1696 | * The return value is always exact and unrounded.
|
1697 | *
|
1698 | * ```ts
|
1699 | * x = new BigNumber('3257869345.0378653')
|
1700 | * BigNumber.max(4e9, x, '123456789.9') // '4000000000'
|
1701 | *
|
1702 | * arr = [12, '13', new BigNumber(14)]
|
1703 | * BigNumber.max.apply(null, arr) // '14'
|
1704 | * ```
|
1705 | *
|
1706 | * @param n A numeric value.
|
1707 | */
|
1708 | static max(...n: BigNumber.Value[]): BigNumber;
|
1709 |
|
1710 | /**
|
1711 | * Returns a BigNumber whose value is the minimum of the arguments.
|
1712 | *
|
1713 | * The return value is always exact and unrounded.
|
1714 | *
|
1715 | * ```ts
|
1716 | * x = new BigNumber('3257869345.0378653')
|
1717 | * BigNumber.minimum(4e9, x, '123456789.9') // '123456789.9'
|
1718 | *
|
1719 | * arr = [2, new BigNumber(-14), '-15.9999', -12]
|
1720 | * BigNumber.minimum.apply(null, arr) // '-15.9999'
|
1721 | * ```
|
1722 | *
|
1723 | * @param n A numeric value.
|
1724 | */
|
1725 | static minimum(...n: BigNumber.Value[]): BigNumber;
|
1726 |
|
1727 | /**
|
1728 | * Returns a BigNumber whose value is the minimum of the arguments.
|
1729 | *
|
1730 | * The return value is always exact and unrounded.
|
1731 | *
|
1732 | * ```ts
|
1733 | * x = new BigNumber('3257869345.0378653')
|
1734 | * BigNumber.min(4e9, x, '123456789.9') // '123456789.9'
|
1735 | *
|
1736 | * arr = [2, new BigNumber(-14), '-15.9999', -12]
|
1737 | * BigNumber.min.apply(null, arr) // '-15.9999'
|
1738 | * ```
|
1739 | *
|
1740 | * @param n A numeric value.
|
1741 | */
|
1742 | static min(...n: BigNumber.Value[]): BigNumber;
|
1743 |
|
1744 | /**
|
1745 | * Returns a new BigNumber with a pseudo-random value equal to or greater than 0 and less than 1.
|
1746 | *
|
1747 | * The return value will have `decimalPlaces` decimal places, or less if trailing zeros are
|
1748 | * produced. If `decimalPlaces` is omitted, the current `DECIMAL_PLACES` setting will be used.
|
1749 | *
|
1750 | * Depending on the value of this BigNumber constructor's `CRYPTO` setting and the support for the
|
1751 | * `crypto` object in the host environment, the random digits of the return value are generated by
|
1752 | * either `Math.random` (fastest), `crypto.getRandomValues` (Web Cryptography API in recent
|
1753 | * browsers) or `crypto.randomBytes` (Node.js).
|
1754 | *
|
1755 | * To be able to set `CRYPTO` to true when using Node.js, the `crypto` object must be available
|
1756 | * globally:
|
1757 | *
|
1758 | * ```ts
|
1759 | * global.crypto = require('crypto')
|
1760 | * ```
|
1761 | *
|
1762 | * If `CRYPTO` is true, i.e. one of the `crypto` methods is to be used, the value of a returned
|
1763 | * BigNumber should be cryptographically secure and statistically indistinguishable from a random
|
1764 | * value.
|
1765 | *
|
1766 | * Throws if `decimalPlaces` is invalid.
|
1767 | *
|
1768 | * ```ts
|
1769 | * BigNumber.config({ DECIMAL_PLACES: 10 })
|
1770 | * BigNumber.random() // '0.4117936847'
|
1771 | * BigNumber.random(20) // '0.78193327636914089009'
|
1772 | * ```
|
1773 | *
|
1774 | * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
|
1775 | */
|
1776 | static random(decimalPlaces?: number): BigNumber;
|
1777 |
|
1778 | /**
|
1779 | * Returns a BigNumber whose value is the sum of the arguments.
|
1780 | *
|
1781 | * The return value is always exact and unrounded.
|
1782 | *
|
1783 | * ```ts
|
1784 | * x = new BigNumber('3257869345.0378653')
|
1785 | * BigNumber.sum(4e9, x, '123456789.9') // '7381326134.9378653'
|
1786 | *
|
1787 | * arr = [2, new BigNumber(14), '15.9999', 12]
|
1788 | * BigNumber.sum.apply(null, arr) // '43.9999'
|
1789 | * ```
|
1790 | *
|
1791 | * @param n A numeric value.
|
1792 | */
|
1793 | static sum(...n: BigNumber.Value[]): BigNumber;
|
1794 |
|
1795 | /**
|
1796 | * Configures the settings that apply to this BigNumber constructor.
|
1797 | *
|
1798 | * The configuration object, `object`, contains any number of the properties shown in the example
|
1799 | * below.
|
1800 | *
|
1801 | * Returns an object with the above properties and their current values.
|
1802 | *
|
1803 | * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the
|
1804 | * properties.
|
1805 | *
|
1806 | * ```ts
|
1807 | * BigNumber.set({
|
1808 | * DECIMAL_PLACES: 40,
|
1809 | * ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
|
1810 | * EXPONENTIAL_AT: [-10, 20],
|
1811 | * RANGE: [-500, 500],
|
1812 | * CRYPTO: true,
|
1813 | * MODULO_MODE: BigNumber.ROUND_FLOOR,
|
1814 | * POW_PRECISION: 80,
|
1815 | * FORMAT: {
|
1816 | * groupSize: 3,
|
1817 | * groupSeparator: ' ',
|
1818 | * decimalSeparator: ','
|
1819 | * },
|
1820 | * ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
|
1821 | * });
|
1822 | *
|
1823 | * BigNumber.set().DECIMAL_PLACES // 40
|
1824 | * ```
|
1825 | *
|
1826 | * @param object The configuration object.
|
1827 | */
|
1828 | static set(object?: BigNumber.Config): BigNumber.Config;
|
1829 | }
|
1830 |
|
1831 | export function BigNumber(n: BigNumber.Value, base?: number): BigNumber;
|