From de98e0b232509d5f40c135d540a70e415272ff85 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 3 May 2017 15:35:00 +0200 Subject: node_modules --- node_modules/big.js/LICENCE | 23 + node_modules/big.js/README.md | 259 +++++++++ node_modules/big.js/big.js | 1142 ++++++++++++++++++++++++++++++++++++++ node_modules/big.js/big.min.js | 1 + node_modules/big.js/package.json | 43 ++ 5 files changed, 1468 insertions(+) create mode 100644 node_modules/big.js/LICENCE create mode 100644 node_modules/big.js/README.md create mode 100644 node_modules/big.js/big.js create mode 100644 node_modules/big.js/big.min.js create mode 100644 node_modules/big.js/package.json (limited to 'node_modules/big.js') diff --git a/node_modules/big.js/LICENCE b/node_modules/big.js/LICENCE new file mode 100644 index 000000000..c045569bf --- /dev/null +++ b/node_modules/big.js/LICENCE @@ -0,0 +1,23 @@ +The MIT Expat Licence. + +Copyright (c) 2012 Michael Mclaughlin + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/node_modules/big.js/README.md b/node_modules/big.js/README.md new file mode 100644 index 000000000..45687dcd4 --- /dev/null +++ b/node_modules/big.js/README.md @@ -0,0 +1,259 @@ + +# big.js # + +A small, fast JavaScript library for arbitrary-precision decimal arithmetic. + +The little sister to [bignumber.js](https://github.com/MikeMcl/bignumber.js/). +See also [decimal.js](https://github.com/MikeMcl/decimal.js/), and [here](https://github.com/MikeMcl/big.js/wiki) for the difference between them. + +## Features + + - Faster, smaller and easier-to-use than JavaScript versions of Java's BigDecimal + - Only 2.7 KB minified and gzipped + - Simple API + - Replicates the `toExponential`, `toFixed` and `toPrecision` methods of JavaScript's Number type + - Includes a `sqrt` method + - Stores values in an accessible decimal floating point format + - No dependencies + - Comprehensive [documentation](http://mikemcl.github.io/big.js/) and test set + +## Load + +The library is the single JavaScript file *big.js* (or *big.min.js*, which is *big.js* minified). + +It can be loaded via a script tag in an HTML document for the browser + + + +or as a CommonJS, [Node.js](http://nodejs.org) or AMD module using `require`. + + var Big = require('big.js'); + +For Node.js, the library is available from the npm registry: + + $ npm install big.js + + + +## Use + +*In all examples below, `var`, semicolons and `toString` calls are not shown. +If a commented-out value is in quotes it means `toString` has been called on the preceding expression.* + +The library exports a single function: Big, the constructor of Big number instances. +It accepts a value of type Number, String or Big number Object. + + x = new Big(123.4567) + y = Big('123456.7e-3') // 'new' is optional + z = new Big(x) + x.eq(y) && x.eq(z) && y.eq(z) // true + +A Big number is immutable in the sense that it is not changed by its methods. + + 0.3 - 0.1 // 0.19999999999999998 + x = new Big(0.3) + x.minus(0.1) // "0.2" + x // "0.3" + +The methods that return a Big number can be chained. + + x.div(y).plus(z).times(9).minus('1.234567801234567e+8').plus(976.54321).div('2598.11772') + x.sqrt().div(y).pow(3).gt(y.mod(z)) // true + +Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods. + + x = new Big(255.5) + x.toExponential(5) // "2.55500e+2" + x.toFixed(5) // "255.50000" + x.toPrecision(5) // "255.50" + +The maximum number of decimal places and the rounding mode used to round the results of the `div`, `sqrt` and `pow` +(with negative exponent) methods is determined by the value of the `DP` and `RM` properties of the `Big` number constructor. + +The other methods always give the exact result. + +(From *v3.0.0*, multiple Big number constructors can be created, see Change Log below.) + + Big.DP = 10 + Big.RM = 1 + + x = new Big(2); + y = new Big(3); + z = x.div(y) // "0.6666666667" + z.sqrt() // "0.8164965809" + z.pow(-3) // "3.3749999995" + z.times(z) // "0.44444444448888888889" + z.times(z).round(10) // "0.4444444445" + + +The value of a Big number is stored in a decimal floating point format in terms of a coefficient, exponent and sign. + + x = new Big(-123.456); + x.c // [1,2,3,4,5,6] coefficient (i.e. significand) + x.e // 2 exponent + x.s // -1 sign + +For further information see the [API](http://mikemcl.github.io/big.js/) reference from the *doc* folder. + +## Test + +The *test* directory contains the test scripts for each Big number method. + +The tests can be run with Node or a browser. + +To test a single method, from a command-line shell at the *test* directory, use e.g. + + $ node toFixed + +To test all the methods + + $ node every-test + +For the browser, see *single-test.html* and *every-test.html* in the *test/browser* directory. + +*big-vs-number.html* enables some of the methods of big.js to be compared with those of JavaScript's Number type. + +## Performance + +The *perf* directory contains two applications and a *lib* directory containing the BigDecimal libraries used by both. + +*big-vs-bigdecimal.html* tests the performance of big.js against the JavaScript translations of two versions of BigDecimal, its use should be more or less self-explanatory. +(The GWT version doesn't work in IE 6.) + +* GWT: java.math.BigDecimal + +* ICU4J: com.ibm.icu.math.BigDecimal + + +The BigDecimal in Node's npm registry is the GWT version. Despite its seeming popularity I have found it to have some serious bugs, see the Node script *perf/lib/bigdecimal_GWT/bugs.js* for examples of flaws in its *remainder*, *divide* and *compareTo* methods. + +*bigtime.js* is a Node command-line application which tests the performance of big.js against the GWT version of +BigDecimal from the npm registry. + +For example, to compare the time taken by the big.js `plus` method and the BigDecimal `add` method: + + $ node bigtime plus 10000 40 + +This will time 10000 calls to each, using operands of up to 40 random digits and will check that the results match. + +For help: + + $ node bigtime -h + +## Build + +I.e. minify. + +For Node, if uglify-js is installed globally ( `npm install uglify-js -g` ) then + + uglifyjs -o ./big.min.js ./big.js + +will create *big.min.js*. + +The *big.min.js* already present was created with *Microsoft Ajax Minifier 5.11*. + +## TypeScript + +The [DefinitelyTyped](https://github.com/borisyankov/DefinitelyTyped) project has a TypeScript [definitions file](https://github.com/borisyankov/DefinitelyTyped/blob/master/big.js/big.js.d.ts) for big.js. + +The definitions file can be added to your project via the [big.js.TypeScript.DefinitelyTyped](https://www.nuget.org/packages/big.js.TypeScript.DefinitelyTyped/0.0.1) NuGet package or via [tsd](http://definitelytyped.org/tsd/). + + tsd query big.js --action install + +Any questions about the TypeScript definitions file should be addressed to the DefinitelyTyped project. + +## Feedback + +Feedback is welcome. + +Bugs/comments/questions? +Open an issue, or email + +Michael +M8ch88l@gmail.com + +Bitcoin donation to: +**1DppGRQSjVSMgGxuygDEHQuWEdTiVEzJYG** +Thank you + +## Licence + +See LICENCE. + +## Change Log + +####3.1.3 + +* Minor documentation updates. + +####3.1.2 + +* README typo. + +####3.1.1 + +* API documentation update, including FAQ additions. + +####3.1.0 + +* Renamed and exposed `TO_EXP_NEG` and `TO_EXP_POS` as `Big.E_NEG` and + `Big.E_POS`. + +####3.0.2 + +* Remove *.npmignore*, use `files` field in *package.json* instead. + +####3.0.1 + +* Added `sub`, `add` and `mul` aliases. +* Clean-up after lint. + +####3.0.0 + +* 10/12/14 Added [multiple constructor functionality](http://mikemcl.github.io/big.js/#faq). +* No breaking changes or other additions, but a major code reorganisation, + so *v3* seemed appropiate. + +####2.5.2 + +* 1/11/14 Added bower.json. + +####2.5.1 + +* 8/06/14 Amend README requires. + +####2.5.0 + +* 26/01/14 Added `toJSON` method so serialization uses `toString`. + +####2.4.1 + +* 17/10/13 Conform signed zero to IEEEE 754 (2008). + +####2.4.0 + +* 19/09/13 Throw instances of `Error`. + +####2.3.0 + +* 16/09/13 Added `cmp` method. + +####2.2.0 + +* 11/07/13 Added 'round up' mode. + +####2.1.0 + +* 26/06/13 Allow e.g. `.1` and `2.`. + +####2.0.0 + +* 12/05/13 Added `abs` method and replaced `cmp` with `eq`, `gt`, `gte`, `lt`, and `lte` methods. + +####1.0.1 + +* Changed default value of MAX_DP to 1E6 + +####1.0.0 + +* 7/11/2012 Initial release diff --git a/node_modules/big.js/big.js b/node_modules/big.js/big.js new file mode 100644 index 000000000..4db5b3e2f --- /dev/null +++ b/node_modules/big.js/big.js @@ -0,0 +1,1142 @@ +/* big.js v3.1.3 https://github.com/MikeMcl/big.js/LICENCE */ +;(function (global) { + 'use strict'; + +/* + big.js v3.1.3 + A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic. + https://github.com/MikeMcl/big.js/ + Copyright (c) 2014 Michael Mclaughlin + MIT Expat Licence +*/ + +/***************************** EDITABLE DEFAULTS ******************************/ + + // The default values below must be integers within the stated ranges. + + /* + * The maximum number of decimal places of the results of operations + * involving division: div and sqrt, and pow with negative exponents. + */ + var DP = 20, // 0 to MAX_DP + + /* + * The rounding mode used when rounding to the above decimal places. + * + * 0 Towards zero (i.e. truncate, no rounding). (ROUND_DOWN) + * 1 To nearest neighbour. If equidistant, round up. (ROUND_HALF_UP) + * 2 To nearest neighbour. If equidistant, to even. (ROUND_HALF_EVEN) + * 3 Away from zero. (ROUND_UP) + */ + RM = 1, // 0, 1, 2 or 3 + + // The maximum value of DP and Big.DP. + MAX_DP = 1E6, // 0 to 1000000 + + // The maximum magnitude of the exponent argument to the pow method. + MAX_POWER = 1E6, // 1 to 1000000 + + /* + * The exponent value at and beneath which toString returns exponential + * notation. + * JavaScript's Number type: -7 + * -1000000 is the minimum recommended exponent value of a Big. + */ + E_NEG = -7, // 0 to -1000000 + + /* + * The exponent value at and above which toString returns exponential + * notation. + * JavaScript's Number type: 21 + * 1000000 is the maximum recommended exponent value of a Big. + * (This limit is not enforced or checked.) + */ + E_POS = 21, // 0 to 1000000 + +/******************************************************************************/ + + // The shared prototype object. + P = {}, + isValid = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i, + Big; + + + /* + * Create and return a Big constructor. + * + */ + function bigFactory() { + + /* + * The Big constructor and exported function. + * Create and return a new instance of a Big number object. + * + * n {number|string|Big} A numeric value. + */ + function Big(n) { + var x = this; + + // Enable constructor usage without new. + if (!(x instanceof Big)) { + return n === void 0 ? bigFactory() : new Big(n); + } + + // Duplicate. + if (n instanceof Big) { + x.s = n.s; + x.e = n.e; + x.c = n.c.slice(); + } else { + parse(x, n); + } + + /* + * Retain a reference to this Big constructor, and shadow + * Big.prototype.constructor which points to Object. + */ + x.constructor = Big; + } + + Big.prototype = P; + Big.DP = DP; + Big.RM = RM; + Big.E_NEG = E_NEG; + Big.E_POS = E_POS; + + return Big; + } + + + // Private functions + + + /* + * Return a string representing the value of Big x in normal or exponential + * notation to dp fixed decimal places or significant digits. + * + * x {Big} The Big to format. + * dp {number} Integer, 0 to MAX_DP inclusive. + * toE {number} 1 (toExponential), 2 (toPrecision) or undefined (toFixed). + */ + function format(x, dp, toE) { + var Big = x.constructor, + + // The index (normal notation) of the digit that may be rounded up. + i = dp - (x = new Big(x)).e, + c = x.c; + + // Round? + if (c.length > ++dp) { + rnd(x, i, Big.RM); + } + + if (!c[0]) { + ++i; + } else if (toE) { + i = dp; + + // toFixed + } else { + c = x.c; + + // Recalculate i as x.e may have changed if value rounded up. + i = x.e + i + 1; + } + + // Append zeros? + for (; c.length < i; c.push(0)) { + } + i = x.e; + + /* + * 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 normal + * notation. + */ + return toE === 1 || toE && (dp <= i || i <= Big.E_NEG) ? + + // Exponential notation. + (x.s < 0 && c[0] ? '-' : '') + + (c.length > 1 ? c[0] + '.' + c.join('').slice(1) : c[0]) + + (i < 0 ? 'e' : 'e+') + i + + // Normal notation. + : x.toString(); + } + + + /* + * Parse the number or string value passed to a Big constructor. + * + * x {Big} A Big number instance. + * n {number|string} A numeric value. + */ + function parse(x, n) { + var e, i, nL; + + // Minus zero? + if (n === 0 && 1 / n < 0) { + n = '-0'; + + // Ensure n is string and check validity. + } else if (!isValid.test(n += '')) { + throwErr(NaN); + } + + // Determine sign. + x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1; + + // Decimal point? + if ((e = n.indexOf('.')) > -1) { + n = n.replace('.', ''); + } + + // Exponential form? + if ((i = n.search(/e/i)) > 0) { + + // Determine exponent. + if (e < 0) { + e = i; + } + e += +n.slice(i + 1); + n = n.substring(0, i); + + } else if (e < 0) { + + // Integer. + e = n.length; + } + + // Determine leading zeros. + for (i = 0; n.charAt(i) == '0'; i++) { + } + + if (i == (nL = n.length)) { + + // Zero. + x.c = [ x.e = 0 ]; + } else { + + // Determine trailing zeros. + for (; n.charAt(--nL) == '0';) { + } + + x.e = e - i - 1; + x.c = []; + + // Convert string to array of digits without leading/trailing zeros. + for (e = 0; i <= nL; x.c[e++] = +n.charAt(i++)) { + } + } + + return x; + } + + + /* + * Round Big x to a maximum of dp decimal places using rounding mode rm. + * Called by div, sqrt and round. + * + * x {Big} The Big to round. + * dp {number} Integer, 0 to MAX_DP inclusive. + * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP) + * [more] {boolean} Whether the result of division was truncated. + */ + function rnd(x, dp, rm, more) { + var u, + xc = x.c, + i = x.e + dp + 1; + + if (rm === 1) { + + // xc[i] is the digit after the digit that may be rounded up. + more = xc[i] >= 5; + } else if (rm === 2) { + more = xc[i] > 5 || xc[i] == 5 && + (more || i < 0 || xc[i + 1] !== u || xc[i - 1] & 1); + } else if (rm === 3) { + more = more || xc[i] !== u || i < 0; + } else { + more = false; + + if (rm !== 0) { + throwErr('!Big.RM!'); + } + } + + if (i < 1 || !xc[0]) { + + if (more) { + + // 1, 0.1, 0.01, 0.001, 0.0001 etc. + x.e = -dp; + x.c = [1]; + } else { + + // Zero. + x.c = [x.e = 0]; + } + } else { + + // Remove any digits after the required decimal places. + xc.length = i--; + + // Round up? + if (more) { + + // Rounding up may mean the previous digit has to be rounded up. + for (; ++xc[i] > 9;) { + xc[i] = 0; + + if (!i--) { + ++x.e; + xc.unshift(1); + } + } + } + + // Remove trailing zeros. + for (i = xc.length; !xc[--i]; xc.pop()) { + } + } + + return x; + } + + + /* + * Throw a BigError. + * + * message {string} The error message. + */ + function throwErr(message) { + var err = new Error(message); + err.name = 'BigError'; + + throw err; + } + + + // Prototype/instance methods + + + /* + * Return a new Big whose value is the absolute value of this Big. + */ + P.abs = function () { + var x = new this.constructor(this); + x.s = 1; + + return x; + }; + + + /* + * Return + * 1 if the value of this Big is greater than the value of Big y, + * -1 if the value of this Big is less than the value of Big y, or + * 0 if they have the same value. + */ + P.cmp = function (y) { + var xNeg, + x = this, + xc = x.c, + yc = (y = new x.constructor(y)).c, + i = x.s, + j = y.s, + k = x.e, + l = y.e; + + // Either zero? + if (!xc[0] || !yc[0]) { + return !xc[0] ? !yc[0] ? 0 : -j : i; + } + + // Signs differ? + if (i != j) { + return i; + } + xNeg = i < 0; + + // Compare exponents. + if (k != l) { + return k > l ^ xNeg ? 1 : -1; + } + + i = -1; + j = (k = xc.length) < (l = yc.length) ? k : l; + + // Compare digit by digit. + for (; ++i < j;) { + + if (xc[i] != yc[i]) { + return xc[i] > yc[i] ^ xNeg ? 1 : -1; + } + } + + // Compare lengths. + return k == l ? 0 : k > l ^ xNeg ? 1 : -1; + }; + + + /* + * Return a new Big whose value is the value of this Big divided by the + * value of Big y, rounded, if necessary, to a maximum of Big.DP decimal + * places using rounding mode Big.RM. + */ + P.div = function (y) { + var x = this, + Big = x.constructor, + // dividend + dvd = x.c, + //divisor + dvs = (y = new Big(y)).c, + s = x.s == y.s ? 1 : -1, + dp = Big.DP; + + if (dp !== ~~dp || dp < 0 || dp > MAX_DP) { + throwErr('!Big.DP!'); + } + + // Either 0? + if (!dvd[0] || !dvs[0]) { + + // If both are 0, throw NaN + if (dvd[0] == dvs[0]) { + throwErr(NaN); + } + + // If dvs is 0, throw +-Infinity. + if (!dvs[0]) { + throwErr(s / 0); + } + + // dvd is 0, return +-0. + return new Big(s * 0); + } + + var dvsL, dvsT, next, cmp, remI, u, + dvsZ = dvs.slice(), + dvdI = dvsL = dvs.length, + dvdL = dvd.length, + // remainder + rem = dvd.slice(0, dvsL), + remL = rem.length, + // quotient + q = y, + qc = q.c = [], + qi = 0, + digits = dp + (q.e = x.e - y.e) + 1; + + q.s = s; + s = digits < 0 ? 0 : digits; + + // Create version of divisor with leading zero. + dvsZ.unshift(0); + + // Add zeros to make remainder as long as divisor. + for (; remL++ < dvsL; rem.push(0)) { + } + + do { + + // 'next' is how many times the divisor goes into current remainder. + for (next = 0; next < 10; next++) { + + // Compare divisor and remainder. + if (dvsL != (remL = rem.length)) { + cmp = dvsL > remL ? 1 : -1; + } else { + + for (remI = -1, cmp = 0; ++remI < dvsL;) { + + if (dvs[remI] != rem[remI]) { + cmp = dvs[remI] > rem[remI] ? 1 : -1; + break; + } + } + } + + // If divisor < remainder, subtract divisor from remainder. + if (cmp < 0) { + + // Remainder can't be more than 1 digit longer than divisor. + // Equalise lengths using divisor with extra leading zero? + for (dvsT = remL == dvsL ? dvs : dvsZ; remL;) { + + if (rem[--remL] < dvsT[remL]) { + remI = remL; + + for (; remI && !rem[--remI]; rem[remI] = 9) { + } + --rem[remI]; + rem[remL] += 10; + } + rem[remL] -= dvsT[remL]; + } + for (; !rem[0]; rem.shift()) { + } + } else { + break; + } + } + + // Add the 'next' digit to the result array. + qc[qi++] = cmp ? next : ++next; + + // Update the remainder. + if (rem[0] && cmp) { + rem[remL] = dvd[dvdI] || 0; + } else { + rem = [ dvd[dvdI] ]; + } + + } while ((dvdI++ < dvdL || rem[0] !== u) && s--); + + // Leading zero? Do not remove if result is simply zero (qi == 1). + if (!qc[0] && qi != 1) { + + // There can't be more than one zero. + qc.shift(); + q.e--; + } + + // Round? + if (qi > digits) { + rnd(q, dp, Big.RM, rem[0] !== u); + } + + return q; + }; + + + /* + * Return true if the value of this Big is equal to the value of Big y, + * otherwise returns false. + */ + P.eq = function (y) { + return !this.cmp(y); + }; + + + /* + * Return true if the value of this Big is greater than the value of Big y, + * otherwise returns false. + */ + P.gt = function (y) { + return this.cmp(y) > 0; + }; + + + /* + * Return true if the value of this Big is greater than or equal to the + * value of Big y, otherwise returns false. + */ + P.gte = function (y) { + return this.cmp(y) > -1; + }; + + + /* + * Return true if the value of this Big is less than the value of Big y, + * otherwise returns false. + */ + P.lt = function (y) { + return this.cmp(y) < 0; + }; + + + /* + * Return true if the value of this Big is less than or equal to the value + * of Big y, otherwise returns false. + */ + P.lte = function (y) { + return this.cmp(y) < 1; + }; + + + /* + * Return a new Big whose value is the value of this Big minus the value + * of Big y. + */ + P.sub = P.minus = function (y) { + var i, j, t, xLTy, + x = this, + Big = x.constructor, + a = x.s, + b = (y = new Big(y)).s; + + // Signs differ? + if (a != b) { + y.s = -b; + return x.plus(y); + } + + var xc = x.c.slice(), + xe = x.e, + yc = y.c, + ye = y.e; + + // Either zero? + if (!xc[0] || !yc[0]) { + + // y is non-zero? x is non-zero? Or both are zero. + return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0); + } + + // Determine which is the bigger number. + // Prepend zeros to equalise exponents. + if (a = xe - ye) { + + if (xLTy = a < 0) { + a = -a; + t = xc; + } else { + ye = xe; + t = yc; + } + + t.reverse(); + for (b = a; b--; t.push(0)) { + } + t.reverse(); + } else { + + // Exponents equal. Check digit by digit. + j = ((xLTy = xc.length < yc.length) ? xc : yc).length; + + 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; + } + + /* + * Append zeros to xc if shorter. No need to add zeros to yc if shorter + * as subtraction only needs to start at yc.length. + */ + if (( b = (j = yc.length) - (i = xc.length) ) > 0) { + + for (; b--; xc[i++] = 0) { + } + } + + // Subtract yc from xc. + for (b = i; j > a;){ + + if (xc[--j] < yc[j]) { + + for (i = j; i && !xc[--i]; xc[i] = 9) { + } + --xc[i]; + xc[j] += 10; + } + xc[j] -= yc[j]; + } + + // Remove trailing zeros. + for (; xc[--b] === 0; xc.pop()) { + } + + // Remove leading zeros and adjust exponent accordingly. + for (; xc[0] === 0;) { + xc.shift(); + --ye; + } + + if (!xc[0]) { + + // n - n = +0 + y.s = 1; + + // Result must be zero. + xc = [ye = 0]; + } + + y.c = xc; + y.e = ye; + + return y; + }; + + + /* + * Return a new Big whose value is the value of this Big modulo the + * value of Big y. + */ + P.mod = function (y) { + var yGTx, + x = this, + Big = x.constructor, + a = x.s, + b = (y = new Big(y)).s; + + if (!y.c[0]) { + throwErr(NaN); + } + + x.s = y.s = 1; + yGTx = y.cmp(x) == 1; + x.s = a; + y.s = b; + + if (yGTx) { + return new Big(x); + } + + a = Big.DP; + b = Big.RM; + Big.DP = Big.RM = 0; + x = x.div(y); + Big.DP = a; + Big.RM = b; + + return this.minus( x.times(y) ); + }; + + + /* + * Return a new Big whose value is the value of this Big plus the value + * of Big y. + */ + P.add = P.plus = function (y) { + var t, + x = this, + Big = x.constructor, + a = x.s, + b = (y = new Big(y)).s; + + // Signs differ? + if (a != b) { + y.s = -b; + return x.minus(y); + } + + var xe = x.e, + xc = x.c, + ye = y.e, + yc = y.c; + + // Either zero? + if (!xc[0] || !yc[0]) { + + // y is non-zero? x is non-zero? Or both are zero. + return yc[0] ? y : new Big(xc[0] ? x : a * 0); + } + xc = xc.slice(); + + // Prepend zeros to equalise exponents. + // Note: 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(); + } + + // Point xc to the longer array. + if (xc.length - yc.length < 0) { + t = yc; + yc = xc; + xc = t; + } + a = yc.length; + + /* + * Only start adding at yc.length - 1 as the further digits of xc can be + * left as they are. + */ + for (b = 0; a;) { + b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0; + xc[a] %= 10; + } + + // No need to check for zero, as +x + +y != 0 && -x + -y != 0 + + if (b) { + xc.unshift(b); + ++ye; + } + + // Remove trailing zeros. + for (a = xc.length; xc[--a] === 0; xc.pop()) { + } + + y.c = xc; + y.e = ye; + + return y; + }; + + + /* + * Return a Big whose value is the value of this Big raised to the power n. + * If n is negative, round, if necessary, to a maximum of Big.DP decimal + * places using rounding mode Big.RM. + * + * n {number} Integer, -MAX_POWER to MAX_POWER inclusive. + */ + P.pow = function (n) { + var x = this, + one = new x.constructor(1), + y = one, + isNeg = n < 0; + + if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) { + throwErr('!pow!'); + } + + n = isNeg ? -n : n; + + for (;;) { + + if (n & 1) { + y = y.times(x); + } + n >>= 1; + + if (!n) { + break; + } + x = x.times(x); + } + + return isNeg ? one.div(y) : y; + }; + + + /* + * Return a new Big whose value is the value of this Big rounded to a + * maximum of dp decimal places using rounding mode rm. + * If dp is not specified, round to 0 decimal places. + * If rm is not specified, use Big.RM. + * + * [dp] {number} Integer, 0 to MAX_DP inclusive. + * [rm] 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP) + */ + P.round = function (dp, rm) { + var x = this, + Big = x.constructor; + + if (dp == null) { + dp = 0; + } else if (dp !== ~~dp || dp < 0 || dp > MAX_DP) { + throwErr('!round!'); + } + rnd(x = new Big(x), dp, rm == null ? Big.RM : rm); + + return x; + }; + + + /* + * Return a new Big whose value is the square root of the value of this Big, + * rounded, if necessary, to a maximum of Big.DP decimal places using + * rounding mode Big.RM. + */ + P.sqrt = function () { + var estimate, r, approx, + x = this, + Big = x.constructor, + xc = x.c, + i = x.s, + e = x.e, + half = new Big('0.5'); + + // Zero? + if (!xc[0]) { + return new Big(x); + } + + // If negative, throw NaN. + if (i < 0) { + throwErr(NaN); + } + + // Estimate. + i = Math.sqrt(x.toString()); + + // Math.sqrt underflow/overflow? + // Pass x to Math.sqrt as integer, then adjust the result exponent. + if (i === 0 || i === 1 / 0) { + estimate = xc.join(''); + + if (!(estimate.length + e & 1)) { + estimate += '0'; + } + + r = new Big( Math.sqrt(estimate).toString() ); + r.e = ((e + 1) / 2 | 0) - (e < 0 || e & 1); + } else { + r = new Big(i.toString()); + } + + i = r.e + (Big.DP += 4); + + // Newton-Raphson iteration. + do { + approx = r; + r = half.times( approx.plus( x.div(approx) ) ); + } while ( approx.c.slice(0, i).join('') !== + r.c.slice(0, i).join('') ); + + rnd(r, Big.DP -= 4, Big.RM); + + return r; + }; + + + /* + * Return a new Big whose value is the value of this Big times the value of + * Big y. + */ + P.mul = P.times = function (y) { + var c, + x = this, + Big = x.constructor, + xc = x.c, + yc = (y = new Big(y)).c, + a = xc.length, + b = yc.length, + i = x.e, + j = y.e; + + // Determine sign of result. + y.s = x.s == y.s ? 1 : -1; + + // Return signed 0 if either 0. + if (!xc[0] || !yc[0]) { + return new Big(y.s * 0); + } + + // Initialise exponent of result as x.e + y.e. + y.e = i + j; + + // If array xc has fewer digits than yc, swap xc and yc, and lengths. + if (a < b) { + c = xc; + xc = yc; + yc = c; + j = a; + a = b; + b = j; + } + + // Initialise coefficient array of result with zeros. + for (c = new Array(j = a + b); j--; c[j] = 0) { + } + + // Multiply. + + // i is initially xc.length. + for (i = b; i--;) { + b = 0; + + // a is yc.length. + for (j = a + i; j > i;) { + + // Current sum of products at this digit position, plus carry. + b = c[j] + yc[i] * xc[j - i - 1] + b; + c[j--] = b % 10; + + // carry + b = b / 10 | 0; + } + c[j] = (c[j] + b) % 10; + } + + // Increment result exponent if there is a final carry. + if (b) { + ++y.e; + } + + // Remove any leading zero. + if (!c[0]) { + c.shift(); + } + + // Remove trailing zeros. + for (i = c.length; !c[--i]; c.pop()) { + } + y.c = c; + + return y; + }; + + + /* + * Return a string representing the value of this Big. + * Return exponential notation if this Big has a positive exponent equal to + * or greater than Big.E_POS, or a negative exponent equal to or less than + * Big.E_NEG. + */ + P.toString = P.valueOf = P.toJSON = function () { + var x = this, + Big = x.constructor, + e = x.e, + str = x.c.join(''), + strL = str.length; + + // Exponential notation? + if (e <= Big.E_NEG || e >= Big.E_POS) { + str = str.charAt(0) + (strL > 1 ? '.' + str.slice(1) : '') + + (e < 0 ? 'e' : 'e+') + e; + + // Negative exponent? + } else if (e < 0) { + + // Prepend zeros. + for (; ++e; str = '0' + str) { + } + str = '0.' + str; + + // Positive exponent? + } else if (e > 0) { + + if (++e > strL) { + + // Append zeros. + for (e -= strL; e-- ; str += '0') { + } + } else if (e < strL) { + str = str.slice(0, e) + '.' + str.slice(e); + } + + // Exponent zero. + } else if (strL > 1) { + str = str.charAt(0) + '.' + str.slice(1); + } + + // Avoid '-0' + return x.s < 0 && x.c[0] ? '-' + str : str; + }; + + + /* + *************************************************************************** + * If toExponential, toFixed, toPrecision and format are not required they + * can safely be commented-out or deleted. No redundant code will be left. + * format is used only by toExponential, toFixed and toPrecision. + *************************************************************************** + */ + + + /* + * Return a string representing the value of this Big in exponential + * notation to dp fixed decimal places and rounded, if necessary, using + * Big.RM. + * + * [dp] {number} Integer, 0 to MAX_DP inclusive. + */ + P.toExponential = function (dp) { + + if (dp == null) { + dp = this.c.length - 1; + } else if (dp !== ~~dp || dp < 0 || dp > MAX_DP) { + throwErr('!toExp!'); + } + + return format(this, dp, 1); + }; + + + /* + * Return a string representing the value of this Big in normal notation + * to dp fixed decimal places and rounded, if necessary, using Big.RM. + * + * [dp] {number} Integer, 0 to MAX_DP inclusive. + */ + P.toFixed = function (dp) { + var str, + x = this, + Big = x.constructor, + neg = Big.E_NEG, + pos = Big.E_POS; + + // Prevent the possibility of exponential notation. + Big.E_NEG = -(Big.E_POS = 1 / 0); + + if (dp == null) { + str = x.toString(); + } else if (dp === ~~dp && dp >= 0 && dp <= MAX_DP) { + str = format(x, x.e + dp); + + // (-0).toFixed() is '0', but (-0.1).toFixed() is '-0'. + // (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'. + if (x.s < 0 && x.c[0] && str.indexOf('-') < 0) { + //E.g. -0.5 if rounded to -0 will cause toString to omit the minus sign. + str = '-' + str; + } + } + Big.E_NEG = neg; + Big.E_POS = pos; + + if (!str) { + throwErr('!toFix!'); + } + + return str; + }; + + + /* + * Return a string representing the value of this Big rounded to sd + * significant digits using Big.RM. Use exponential notation if sd is less + * than the number of digits necessary to represent the integer part of the + * value in normal notation. + * + * sd {number} Integer, 1 to MAX_DP inclusive. + */ + P.toPrecision = function (sd) { + + if (sd == null) { + return this.toString(); + } else if (sd !== ~~sd || sd < 1 || sd > MAX_DP) { + throwErr('!toPre!'); + } + + return format(this, sd - 1, 2); + }; + + + // Export + + + Big = bigFactory(); + + //AMD. + if (typeof define === 'function' && define.amd) { + define(function () { + return Big; + }); + + // Node and other CommonJS-like environments that support module.exports. + } else if (typeof module !== 'undefined' && module.exports) { + module.exports = Big; + + //Browser. + } else { + global.Big = Big; + } +})(this); diff --git a/node_modules/big.js/big.min.js b/node_modules/big.js/big.min.js new file mode 100644 index 000000000..aeef27f1d --- /dev/null +++ b/node_modules/big.js/big.min.js @@ -0,0 +1 @@ +/* big.js v3.1.3 https://github.com/MikeMcl/big.js/LICENCE */(function(global){"use strict";var DP=20,RM=1,MAX_DP=1e6,MAX_POWER=1e6,E_NEG=-7,E_POS=21,P={},isValid=/^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,Big;function bigFactory(){function Big(n){var x=this;if(!(x instanceof Big)){return n===void 0?bigFactory():new Big(n)}if(n instanceof Big){x.s=n.s;x.e=n.e;x.c=n.c.slice()}else{parse(x,n)}x.constructor=Big}Big.prototype=P;Big.DP=DP;Big.RM=RM;Big.E_NEG=E_NEG;Big.E_POS=E_POS;return Big}function format(x,dp,toE){var Big=x.constructor,i=dp-(x=new Big(x)).e,c=x.c;if(c.length>++dp){rnd(x,i,Big.RM)}if(!c[0]){++i}else if(toE){i=dp}else{c=x.c;i=x.e+i+1}for(;c.length1?c[0]+"."+c.join("").slice(1):c[0])+(i<0?"e":"e+")+i:x.toString()}function parse(x,n){var e,i,nL;if(n===0&&1/n<0){n="-0"}else if(!isValid.test(n+="")){throwErr(NaN)}x.s=n.charAt(0)=="-"?(n=n.slice(1),-1):1;if((e=n.indexOf("."))>-1){n=n.replace(".","")}if((i=n.search(/e/i))>0){if(e<0){e=i}e+=+n.slice(i+1);n=n.substring(0,i)}else if(e<0){e=n.length}for(i=0;n.charAt(i)=="0";i++){}if(i==(nL=n.length)){x.c=[x.e=0]}else{for(;n.charAt(--nL)=="0";){}x.e=e-i-1;x.c=[];for(e=0;i<=nL;x.c[e++]=+n.charAt(i++)){}}return x}function rnd(x,dp,rm,more){var u,xc=x.c,i=x.e+dp+1;if(rm===1){more=xc[i]>=5}else if(rm===2){more=xc[i]>5||xc[i]==5&&(more||i<0||xc[i+1]!==u||xc[i-1]&1)}else if(rm===3){more=more||xc[i]!==u||i<0}else{more=false;if(rm!==0){throwErr("!Big.RM!")}}if(i<1||!xc[0]){if(more){x.e=-dp;x.c=[1]}else{x.c=[x.e=0]}}else{xc.length=i--;if(more){for(;++xc[i]>9;){xc[i]=0;if(!i--){++x.e;xc.unshift(1)}}}for(i=xc.length;!xc[--i];xc.pop()){}}return x}function throwErr(message){var err=new Error(message);err.name="BigError";throw err}P.abs=function(){var x=new this.constructor(this);x.s=1;return x};P.cmp=function(y){var xNeg,x=this,xc=x.c,yc=(y=new x.constructor(y)).c,i=x.s,j=y.s,k=x.e,l=y.e;if(!xc[0]||!yc[0]){return!xc[0]?!yc[0]?0:-j:i}if(i!=j){return i}xNeg=i<0;if(k!=l){return k>l^xNeg?1:-1}i=-1;j=(k=xc.length)<(l=yc.length)?k:l;for(;++iyc[i]^xNeg?1:-1}}return k==l?0:k>l^xNeg?1:-1};P.div=function(y){var x=this,Big=x.constructor,dvd=x.c,dvs=(y=new Big(y)).c,s=x.s==y.s?1:-1,dp=Big.DP;if(dp!==~~dp||dp<0||dp>MAX_DP){throwErr("!Big.DP!")}if(!dvd[0]||!dvs[0]){if(dvd[0]==dvs[0]){throwErr(NaN)}if(!dvs[0]){throwErr(s/0)}return new Big(s*0)}var dvsL,dvsT,next,cmp,remI,u,dvsZ=dvs.slice(),dvdI=dvsL=dvs.length,dvdL=dvd.length,rem=dvd.slice(0,dvsL),remL=rem.length,q=y,qc=q.c=[],qi=0,digits=dp+(q.e=x.e-y.e)+1;q.s=s;s=digits<0?0:digits;dvsZ.unshift(0);for(;remL++remL?1:-1}else{for(remI=-1,cmp=0;++remIrem[remI]?1:-1;break}}}if(cmp<0){for(dvsT=remL==dvsL?dvs:dvsZ;remL;){if(rem[--remL]digits){rnd(q,dp,Big.RM,rem[0]!==u)}return q};P.eq=function(y){return!this.cmp(y)};P.gt=function(y){return this.cmp(y)>0};P.gte=function(y){return this.cmp(y)>-1};P.lt=function(y){return this.cmp(y)<0};P.lte=function(y){return this.cmp(y)<1};P.sub=P.minus=function(y){var i,j,t,xLTy,x=this,Big=x.constructor,a=x.s,b=(y=new Big(y)).s;if(a!=b){y.s=-b;return x.plus(y)}var xc=x.c.slice(),xe=x.e,yc=y.c,ye=y.e;if(!xc[0]||!yc[0]){return yc[0]?(y.s=-b,y):new Big(xc[0]?x:0)}if(a=xe-ye){if(xLTy=a<0){a=-a;t=xc}else{ye=xe;t=yc}t.reverse();for(b=a;b--;t.push(0)){}t.reverse()}else{j=((xLTy=xc.length0){for(;b--;xc[i++]=0){}}for(b=i;j>a;){if(xc[--j]0){ye=xe;t=yc}else{a=-a;t=xc}t.reverse();for(;a--;t.push(0)){}t.reverse()}if(xc.length-yc.length<0){t=yc;yc=xc;xc=t}a=yc.length;for(b=0;a;){b=(xc[--a]=xc[a]+yc[a]+b)/10|0;xc[a]%=10}if(b){xc.unshift(b);++ye}for(a=xc.length;xc[--a]===0;xc.pop()){}y.c=xc;y.e=ye;return y};P.pow=function(n){var x=this,one=new x.constructor(1),y=one,isNeg=n<0;if(n!==~~n||n<-MAX_POWER||n>MAX_POWER){throwErr("!pow!")}n=isNeg?-n:n;for(;;){if(n&1){y=y.times(x)}n>>=1;if(!n){break}x=x.times(x)}return isNeg?one.div(y):y};P.round=function(dp,rm){var x=this,Big=x.constructor;if(dp==null){dp=0}else if(dp!==~~dp||dp<0||dp>MAX_DP){throwErr("!round!")}rnd(x=new Big(x),dp,rm==null?Big.RM:rm);return x};P.sqrt=function(){var estimate,r,approx,x=this,Big=x.constructor,xc=x.c,i=x.s,e=x.e,half=new Big("0.5");if(!xc[0]){return new Big(x)}if(i<0){throwErr(NaN)}i=Math.sqrt(x.toString());if(i===0||i===1/0){estimate=xc.join("");if(!(estimate.length+e&1)){estimate+="0"}r=new Big(Math.sqrt(estimate).toString());r.e=((e+1)/2|0)-(e<0||e&1)}else{r=new Big(i.toString())}i=r.e+(Big.DP+=4);do{approx=r;r=half.times(approx.plus(x.div(approx)))}while(approx.c.slice(0,i).join("")!==r.c.slice(0,i).join(""));rnd(r,Big.DP-=4,Big.RM);return r};P.mul=P.times=function(y){var c,x=this,Big=x.constructor,xc=x.c,yc=(y=new Big(y)).c,a=xc.length,b=yc.length,i=x.e,j=y.e;y.s=x.s==y.s?1:-1;if(!xc[0]||!yc[0]){return new Big(y.s*0)}y.e=i+j;if(ai;){b=c[j]+yc[i]*xc[j-i-1]+b;c[j--]=b%10;b=b/10|0}c[j]=(c[j]+b)%10}if(b){++y.e}if(!c[0]){c.shift()}for(i=c.length;!c[--i];c.pop()){}y.c=c;return y};P.toString=P.valueOf=P.toJSON=function(){var x=this,Big=x.constructor,e=x.e,str=x.c.join(""),strL=str.length;if(e<=Big.E_NEG||e>=Big.E_POS){str=str.charAt(0)+(strL>1?"."+str.slice(1):"")+(e<0?"e":"e+")+e}else if(e<0){for(;++e;str="0"+str){}str="0."+str}else if(e>0){if(++e>strL){for(e-=strL;e--;str+="0"){}}else if(e1){str=str.charAt(0)+"."+str.slice(1)}return x.s<0&&x.c[0]?"-"+str:str};P.toExponential=function(dp){if(dp==null){dp=this.c.length-1}else if(dp!==~~dp||dp<0||dp>MAX_DP){throwErr("!toExp!")}return format(this,dp,1)};P.toFixed=function(dp){var str,x=this,Big=x.constructor,neg=Big.E_NEG,pos=Big.E_POS;Big.E_NEG=-(Big.E_POS=1/0);if(dp==null){str=x.toString()}else if(dp===~~dp&&dp>=0&&dp<=MAX_DP){str=format(x,x.e+dp);if(x.s<0&&x.c[0]&&str.indexOf("-")<0){str="-"+str}}Big.E_NEG=neg;Big.E_POS=pos;if(!str){throwErr("!toFix!")}return str};P.toPrecision=function(sd){if(sd==null){return this.toString()}else if(sd!==~~sd||sd<1||sd>MAX_DP){throwErr("!toPre!")}return format(this,sd-1,2)};Big=bigFactory();if(typeof define==="function"&&define.amd){define(function(){return Big})}else if(typeof module!=="undefined"&&module.exports){module.exports=Big}else{global.Big=Big}})(this); diff --git a/node_modules/big.js/package.json b/node_modules/big.js/package.json new file mode 100644 index 000000000..af09fef4a --- /dev/null +++ b/node_modules/big.js/package.json @@ -0,0 +1,43 @@ +{ + "name": "big.js", + "description": "A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic", + "version": "3.1.3", + "keywords": [ + "arbitrary", + "precision", + "arithmetic", + "big", + "number", + "decimal", + "float", + "biginteger", + "bigdecimal", + "bignumber", + "bigint", + "bignum" + ], + "repository" : { + "type": "git", + "url": "https://github.com/MikeMcl/big.js.git" + }, + "main": "./big", + "author": { + "name": "Michael Mclaughlin", + "email": "M8ch88l@gmail.com" + }, + "bugs": { + "url": "https://github.com/MikeMcl/big.js/issues" + }, + "engines": { + "node": "*" + }, + "license": "MIT", + "scripts": { + "test": "node ./test/every-test.js", + "build": "uglifyjs -o ./big.min.js ./big.js" + }, + "files": [ + "big.js", + "big.min.js" + ] +} -- cgit v1.2.3