{"version":3,"sources":["webpack:///./node_modules/decimal.js/decimal.js"],"names":["globalScope","Decimal","inexact","quadrant","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","PI","DEFAULTS","precision","rounding","modulo","toExpNeg","toExpPos","minE","maxE","crypto","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","mathfloor","Math","floor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LOG_BASE","MAX_SAFE_INTEGER","LN10_PRECISION","length","PI_PRECISION","P","name","digitsToString","d","i","k","ws","indexOfLastWord","str","w","getZeroString","checkInt32","min","max","Error","checkRoundingDigits","rm","repeating","di","r","rd","ceil","convertBase","baseIn","baseOut","j","arrL","arr","strL","indexOf","charAt","reverse","cosine","Ctor","x","y","len","tinyPow","toString","taylorSeries","times","cos2x","minus","plus","absoluteValue","abs","this","constructor","s","finalise","e","comparedTo","cmp","xdL","ydL","xd","yd","xs","ys","NaN","cos","pr","sd","toLessThanHalfPi","neg","cubeRoot","cbrt","m","n","rep","t","t3","t3plusx","isFinite","isZero","toExponential","slice","divide","eq","decimalPlaces","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","gt","greaterThanOrEqualTo","gte","hyperbolicCosine","cosh","one","cosh2_x","d8","hyperbolicSine","sinh","sqrt","sinh2_x","d5","d16","d20","hyperbolicTangent","tanh","inverseCosine","acos","halfPi","isNeg","getPi","asin","inverseHyperbolicCosine","acosh","lte","ln","inverseHyperbolicSine","asinh","inverseHyperbolicTangent","atanh","wpr","xsd","inverseSine","atan","inverseTangent","px","x2","isInteger","isInt","isNaN","isNegative","isPositive","isPos","lessThan","lt","lessThanOrEqualTo","logarithm","log","base","isBase10","denominator","inf","num","arg","guard","naturalLogarithm","getLn10","sub","xe","xLTy","push","pop","shift","getBase10Exponent","mod","q","naturalExponential","exp","negated","add","carry","unshift","z","getPrecision","round","sine","sin","squareRoot","tangent","tan","mul","rL","toBinary","toStringBinary","toDecimalPlaces","toDP","finiteToString","toFixed","toFraction","maxD","d0","d1","d2","n0","n1","toHexadecimal","toHex","toNearest","toNumber","toOctal","toPower","yn","intPow","toPrecision","toSignificantDigits","toSD","truncated","trunc","valueOf","toJSON","multiplyInteger","temp","compare","a","b","aL","bL","subtract","logBase","more","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","sign","isTruncated","digits","roundUp","xdi","out","isExp","nonFiniteToString","zs","truncate","isOdd","maxOrMin","args","ltgt","sum","c","c0","numerator","x1","String","parseDecimal","replace","search","substring","charCodeAt","parseOther","divisor","isFloat","p","test","toLowerCase","sin2_x","isHyperbolic","u","pi","atan2","config","obj","v","useDefaults","defaults","ps","getRandomValues","randomBytes","clone","prototype","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","set","isDecimalInstance","hypot","log10","log2","random","hasOwnProperty","arguments","Uint32Array","copy"],"mappings":"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","file":"js/chunk-2d0c0279.92f67134.js","sourcesContent":[";(function (globalScope) {\r\n 'use strict';\r\n\r\n\r\n /*\r\n * decimal.js v10.2.1\r\n * An arbitrary-precision Decimal type for JavaScript.\r\n * https://github.com/MikeMcl/decimal.js\r\n * Copyright (c) 2020 Michael Mclaughlin \r\n * MIT Licence\r\n */\r\n\r\n\r\n // ----------------------------------- EDITABLE DEFAULTS ------------------------------------ //\r\n\r\n\r\n // The maximum exponent magnitude.\r\n // The limit on the value of `toExpNeg`, `toExpPos`, `minE` and `maxE`.\r\n var EXP_LIMIT = 9e15, // 0 to 9e15\r\n\r\n // The limit on the value of `precision`, and on the value of the first argument to\r\n // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n MAX_DIGITS = 1e9, // 0 to 1e9\r\n\r\n // Base conversion alphabet.\r\n NUMERALS = '0123456789abcdef',\r\n\r\n // The natural logarithm of 10 (1025 digits).\r\n LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',\r\n\r\n // Pi (1025 digits).\r\n PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',\r\n\r\n\r\n // The initial configuration properties of the Decimal constructor.\r\n DEFAULTS = {\r\n\r\n // These values must be integers within the stated ranges (inclusive).\r\n // Most of these values can be changed at run-time using the `Decimal.config` method.\r\n\r\n // The maximum number of significant digits of the result of a calculation or base conversion.\r\n // E.g. `Decimal.config({ precision: 20 });`\r\n precision: 20, // 1 to MAX_DIGITS\r\n\r\n // The rounding mode used when rounding to `precision`.\r\n //\r\n // ROUND_UP 0 Away from zero.\r\n // ROUND_DOWN 1 Towards zero.\r\n // ROUND_CEIL 2 Towards +Infinity.\r\n // ROUND_FLOOR 3 Towards -Infinity.\r\n // ROUND_HALF_UP 4 Towards nearest neighbour. If equidistant, up.\r\n // ROUND_HALF_DOWN 5 Towards nearest neighbour. If equidistant, down.\r\n // ROUND_HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n // ROUND_HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n //\r\n // E.g.\r\n // `Decimal.rounding = 4;`\r\n // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n rounding: 4, // 0 to 8\r\n\r\n // The modulo mode used when calculating the modulus: a mod n.\r\n // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n // The remainder (r) is calculated as: r = a - n * q.\r\n //\r\n // UP 0 The remainder is positive if the dividend is negative, else is negative.\r\n // DOWN 1 The remainder has the same sign as the dividend (JavaScript %).\r\n // FLOOR 3 The remainder has the same sign as the divisor (Python %).\r\n // HALF_EVEN 6 The IEEE 754 remainder function.\r\n // EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.\r\n //\r\n // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian\r\n // division (9) are commonly used for the modulus operation. The other rounding modes can also\r\n // be used, but they may not give useful results.\r\n modulo: 1, // 0 to 9\r\n\r\n // The exponent value at and beneath which `toString` returns exponential notation.\r\n // JavaScript numbers: -7\r\n toExpNeg: -7, // 0 to -EXP_LIMIT\r\n\r\n // The exponent value at and above which `toString` returns exponential notation.\r\n // JavaScript numbers: 21\r\n toExpPos: 21, // 0 to EXP_LIMIT\r\n\r\n // The minimum exponent value, beneath which underflow to zero occurs.\r\n // JavaScript numbers: -324 (5e-324)\r\n minE: -EXP_LIMIT, // -1 to -EXP_LIMIT\r\n\r\n // The maximum exponent value, above which overflow to Infinity occurs.\r\n // JavaScript numbers: 308 (1.7976931348623157e+308)\r\n maxE: EXP_LIMIT, // 1 to EXP_LIMIT\r\n\r\n // Whether to use cryptographically-secure random number generation, if available.\r\n crypto: false // true/false\r\n },\r\n\r\n\r\n // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n Decimal, inexact, noConflict, quadrant,\r\n external = true,\r\n\r\n decimalError = '[DecimalError] ',\r\n invalidArgument = decimalError + 'Invalid argument: ',\r\n precisionLimitExceeded = decimalError + 'Precision limit exceeded',\r\n cryptoUnavailable = decimalError + 'crypto unavailable',\r\n\r\n mathfloor = Math.floor,\r\n mathpow = Math.pow,\r\n\r\n isBinary = /^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,\r\n isHex = /^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,\r\n isOctal = /^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,\r\n isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n BASE = 1e7,\r\n LOG_BASE = 7,\r\n MAX_SAFE_INTEGER = 9007199254740991,\r\n\r\n LN10_PRECISION = LN10.length - 1,\r\n PI_PRECISION = PI.length - 1,\r\n\r\n // Decimal.prototype object\r\n P = { name: '[object Decimal]' };\r\n\r\n\r\n // Decimal prototype methods\r\n\r\n\r\n /*\r\n * absoluteValue abs\r\n * ceil\r\n * comparedTo cmp\r\n * cosine cos\r\n * cubeRoot cbrt\r\n * decimalPlaces dp\r\n * dividedBy div\r\n * dividedToIntegerBy divToInt\r\n * equals eq\r\n * floor\r\n * greaterThan gt\r\n * greaterThanOrEqualTo gte\r\n * hyperbolicCosine cosh\r\n * hyperbolicSine sinh\r\n * hyperbolicTangent tanh\r\n * inverseCosine acos\r\n * inverseHyperbolicCosine acosh\r\n * inverseHyperbolicSine asinh\r\n * inverseHyperbolicTangent atanh\r\n * inverseSine asin\r\n * inverseTangent atan\r\n * isFinite\r\n * isInteger isInt\r\n * isNaN\r\n * isNegative isNeg\r\n * isPositive isPos\r\n * isZero\r\n * lessThan lt\r\n * lessThanOrEqualTo lte\r\n * logarithm log\r\n * [maximum] [max]\r\n * [minimum] [min]\r\n * minus sub\r\n * modulo mod\r\n * naturalExponential exp\r\n * naturalLogarithm ln\r\n * negated neg\r\n * plus add\r\n * precision sd\r\n * round\r\n * sine sin\r\n * squareRoot sqrt\r\n * tangent tan\r\n * times mul\r\n * toBinary\r\n * toDecimalPlaces toDP\r\n * toExponential\r\n * toFixed\r\n * toFraction\r\n * toHexadecimal toHex\r\n * toNearest\r\n * toNumber\r\n * toOctal\r\n * toPower pow\r\n * toPrecision\r\n * toSignificantDigits toSD\r\n * toString\r\n * truncated trunc\r\n * valueOf toJSON\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the absolute value of this Decimal.\r\n *\r\n */\r\n P.absoluteValue = P.abs = function () {\r\n var x = new this.constructor(this);\r\n if (x.s < 0) x.s = 1;\r\n return finalise(x);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of positive Infinity.\r\n *\r\n */\r\n P.ceil = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 2);\r\n };\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if the value of this Decimal is greater than the value of `y`,\r\n * -1 if the value of this Decimal is less than the value of `y`,\r\n * 0 if they have the same value,\r\n * NaN if the value of either Decimal is NaN.\r\n *\r\n */\r\n P.comparedTo = P.cmp = function (y) {\r\n var i, j, xdL, ydL,\r\n x = this,\r\n xd = x.d,\r\n yd = (y = new x.constructor(y)).d,\r\n xs = x.s,\r\n ys = y.s;\r\n\r\n // Either NaN or ±Infinity?\r\n if (!xd || !yd) {\r\n return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;\r\n }\r\n\r\n // Either zero?\r\n if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;\r\n\r\n // Signs differ?\r\n if (xs !== ys) return xs;\r\n\r\n // Compare exponents.\r\n if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;\r\n\r\n xdL = xd.length;\r\n ydL = yd.length;\r\n\r\n // Compare digit by digit.\r\n for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n if (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;\r\n }\r\n\r\n // Compare lengths.\r\n return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * cos(0) = 1\r\n * cos(-0) = 1\r\n * cos(Infinity) = NaN\r\n * cos(-Infinity) = NaN\r\n * cos(NaN) = NaN\r\n *\r\n */\r\n P.cosine = P.cos = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.d) return new Ctor(NaN);\r\n\r\n // cos(0) = cos(-0) = 1\r\n if (!x.d[0]) return new Ctor(1);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n Ctor.rounding = 1;\r\n\r\n x = cosine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n *\r\n * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * cbrt(0) = 0\r\n * cbrt(-0) = -0\r\n * cbrt(1) = 1\r\n * cbrt(-1) = -1\r\n * cbrt(N) = N\r\n * cbrt(-I) = -I\r\n * cbrt(I) = I\r\n *\r\n * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))\r\n *\r\n */\r\n P.cubeRoot = P.cbrt = function () {\r\n var e, m, n, r, rep, s, sd, t, t3, t3plusx,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n external = false;\r\n\r\n // Initial estimate.\r\n s = x.s * mathpow(x.s * x, 1 / 3);\r\n\r\n // Math.cbrt underflow/overflow?\r\n // Pass x to Math.pow as integer, then adjust the exponent of the result.\r\n if (!s || Math.abs(s) == 1 / 0) {\r\n n = digitsToString(x.d);\r\n e = x.e;\r\n\r\n // Adjust n exponent so it is a multiple of 3 away from x exponent.\r\n if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');\r\n s = mathpow(n, 1 / 3);\r\n\r\n // Rarely, e may be one less than the result exponent value.\r\n e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));\r\n\r\n if (s == 1 / 0) {\r\n n = '5e' + e;\r\n } else {\r\n n = s.toExponential();\r\n n = n.slice(0, n.indexOf('e') + 1) + e;\r\n }\r\n\r\n r = new Ctor(n);\r\n r.s = x.s;\r\n } else {\r\n r = new Ctor(s.toString());\r\n }\r\n\r\n sd = (e = Ctor.precision) + 3;\r\n\r\n // Halley's method.\r\n // TODO? Compare Newton's method.\r\n for (;;) {\r\n t = r;\r\n t3 = t.times(t).times(t);\r\n t3plusx = t3.plus(x);\r\n r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);\r\n\r\n // TODO? Replace with for-loop and checkRoundingDigits.\r\n if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n n = n.slice(sd - 3, sd + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999\r\n // , i.e. approaching a rounding boundary, continue the iteration.\r\n if (n == '9999' || !rep && n == '4999') {\r\n\r\n // On the first iteration only, check to see if rounding up gives the exact result as the\r\n // nines may infinitely repeat.\r\n if (!rep) {\r\n finalise(t, e + 1, 0);\r\n\r\n if (t.times(t).times(t).eq(x)) {\r\n r = t;\r\n break;\r\n }\r\n }\r\n\r\n sd += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n // If not, then there are further digits and m will be truthy.\r\n if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n // Truncate to the first rounding digit.\r\n finalise(r, e + 1, 1);\r\n m = !r.times(r).times(r).eq(x);\r\n }\r\n\r\n break;\r\n }\r\n }\r\n }\r\n\r\n external = true;\r\n\r\n return finalise(r, e, Ctor.rounding, m);\r\n };\r\n\r\n\r\n /*\r\n * Return the number of decimal places of the value of this Decimal.\r\n *\r\n */\r\n P.decimalPlaces = P.dp = function () {\r\n var w,\r\n d = this.d,\r\n n = NaN;\r\n\r\n if (d) {\r\n w = d.length - 1;\r\n n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n // Subtract the number of trailing zeros of the last word.\r\n w = d[w];\r\n if (w) for (; w % 10 == 0; w /= 10) n--;\r\n if (n < 0) n = 0;\r\n }\r\n\r\n return n;\r\n };\r\n\r\n\r\n /*\r\n * n / 0 = I\r\n * n / N = N\r\n * n / I = 0\r\n * 0 / n = 0\r\n * 0 / 0 = N\r\n * 0 / N = N\r\n * 0 / I = 0\r\n * N / n = N\r\n * N / 0 = N\r\n * N / N = N\r\n * N / I = N\r\n * I / n = I\r\n * I / 0 = I\r\n * I / N = N\r\n * I / I = N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal divided by `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.dividedBy = P.div = function (y) {\r\n return divide(this, new this.constructor(y));\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n * by the value of `y`, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.dividedToIntegerBy = P.divToInt = function (y) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n *\r\n */\r\n P.equals = P.eq = function (y) {\r\n return this.cmp(y) === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of negative Infinity.\r\n *\r\n */\r\n P.floor = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 3);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n * false.\r\n *\r\n */\r\n P.greaterThan = P.gt = function (y) {\r\n return this.cmp(y) > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is greater than or equal to the value of `y`,\r\n * otherwise return false.\r\n *\r\n */\r\n P.greaterThanOrEqualTo = P.gte = function (y) {\r\n var k = this.cmp(y);\r\n return k == 1 || k === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [1, Infinity]\r\n *\r\n * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...\r\n *\r\n * cosh(0) = 1\r\n * cosh(-0) = 1\r\n * cosh(Infinity) = Infinity\r\n * cosh(-Infinity) = Infinity\r\n * cosh(NaN) = NaN\r\n *\r\n * x time taken (ms) result\r\n * 1000 9 9.8503555700852349694e+433\r\n * 10000 25 4.4034091128314607936e+4342\r\n * 100000 171 1.4033316802130615897e+43429\r\n * 1000000 3817 1.5166076984010437725e+434294\r\n * 10000000 abandoned after 2 minute wait\r\n *\r\n * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))\r\n *\r\n */\r\n P.hyperbolicCosine = P.cosh = function () {\r\n var k, n, pr, rm, len,\r\n x = this,\r\n Ctor = x.constructor,\r\n one = new Ctor(1);\r\n\r\n if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);\r\n if (x.isZero()) return one;\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n len = x.d.length;\r\n\r\n // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1\r\n // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n // TODO? Estimation reused from cosine() and may not be optimal here.\r\n if (len < 32) {\r\n k = Math.ceil(len / 3);\r\n n = (1 / tinyPow(4, k)).toString();\r\n } else {\r\n k = 16;\r\n n = '2.3283064365386962890625e-10';\r\n }\r\n\r\n x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);\r\n\r\n // Reverse argument reduction\r\n var cosh2_x,\r\n i = k,\r\n d8 = new Ctor(8);\r\n for (; i--;) {\r\n cosh2_x = x.times(x);\r\n x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));\r\n }\r\n\r\n return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...\r\n *\r\n * sinh(0) = 0\r\n * sinh(-0) = -0\r\n * sinh(Infinity) = Infinity\r\n * sinh(-Infinity) = -Infinity\r\n * sinh(NaN) = NaN\r\n *\r\n * x time taken (ms)\r\n * 10 2 ms\r\n * 100 5 ms\r\n * 1000 14 ms\r\n * 10000 82 ms\r\n * 100000 886 ms 1.4033316802130615897e+43429\r\n * 200000 2613 ms\r\n * 300000 5407 ms\r\n * 400000 8824 ms\r\n * 500000 13026 ms 8.7080643612718084129e+217146\r\n * 1000000 48543 ms\r\n *\r\n * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))\r\n *\r\n */\r\n P.hyperbolicSine = P.sinh = function () {\r\n var k, pr, rm, len,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n len = x.d.length;\r\n\r\n if (len < 3) {\r\n x = taylorSeries(Ctor, 2, x, x, true);\r\n } else {\r\n\r\n // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))\r\n // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))\r\n // 3 multiplications and 1 addition\r\n\r\n // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))\r\n // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))\r\n // 4 multiplications and 2 additions\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n k = 1.4 * Math.sqrt(len);\r\n k = k > 16 ? 16 : k | 0;\r\n\r\n x = x.times(1 / tinyPow(5, k));\r\n x = taylorSeries(Ctor, 2, x, x, true);\r\n\r\n // Reverse argument reduction\r\n var sinh2_x,\r\n d5 = new Ctor(5),\r\n d16 = new Ctor(16),\r\n d20 = new Ctor(20);\r\n for (; k--;) {\r\n sinh2_x = x.times(x);\r\n x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));\r\n }\r\n }\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * tanh(x) = sinh(x) / cosh(x)\r\n *\r\n * tanh(0) = 0\r\n * tanh(-0) = -0\r\n * tanh(Infinity) = 1\r\n * tanh(-Infinity) = -1\r\n * tanh(NaN) = NaN\r\n *\r\n */\r\n P.hyperbolicTangent = P.tanh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(x.s);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 7;\r\n Ctor.rounding = 1;\r\n\r\n return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of\r\n * this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [0, pi]\r\n *\r\n * acos(x) = pi/2 - asin(x)\r\n *\r\n * acos(0) = pi/2\r\n * acos(-0) = pi/2\r\n * acos(1) = 0\r\n * acos(-1) = pi\r\n * acos(1/2) = pi/3\r\n * acos(-1/2) = 2*pi/3\r\n * acos(|x| > 1) = NaN\r\n * acos(NaN) = NaN\r\n *\r\n */\r\n P.inverseCosine = P.acos = function () {\r\n var halfPi,\r\n x = this,\r\n Ctor = x.constructor,\r\n k = x.abs().cmp(1),\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding;\r\n\r\n if (k !== -1) {\r\n return k === 0\r\n // |x| is 1\r\n ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)\r\n // |x| > 1 or x is NaN\r\n : new Ctor(NaN);\r\n }\r\n\r\n if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3\r\n\r\n Ctor.precision = pr + 6;\r\n Ctor.rounding = 1;\r\n\r\n x = x.asin();\r\n halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return halfPi.minus(x);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [1, Infinity]\r\n * Range: [0, Infinity]\r\n *\r\n * acosh(x) = ln(x + sqrt(x^2 - 1))\r\n *\r\n * acosh(x < 1) = NaN\r\n * acosh(NaN) = NaN\r\n * acosh(Infinity) = Infinity\r\n * acosh(-Infinity) = NaN\r\n * acosh(0) = NaN\r\n * acosh(-0) = NaN\r\n * acosh(1) = 0\r\n * acosh(-1) = NaN\r\n *\r\n */\r\n P.inverseHyperbolicCosine = P.acosh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);\r\n if (!x.isFinite()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n external = false;\r\n\r\n x = x.times(x).minus(1).sqrt().plus(x);\r\n\r\n external = true;\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.ln();\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * asinh(x) = ln(x + sqrt(x^2 + 1))\r\n *\r\n * asinh(NaN) = NaN\r\n * asinh(Infinity) = Infinity\r\n * asinh(-Infinity) = -Infinity\r\n * asinh(0) = 0\r\n * asinh(-0) = -0\r\n *\r\n */\r\n P.inverseHyperbolicSine = P.asinh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;\r\n Ctor.rounding = 1;\r\n external = false;\r\n\r\n x = x.times(x).plus(1).sqrt().plus(x);\r\n\r\n external = true;\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.ln();\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * atanh(x) = 0.5 * ln((1 + x) / (1 - x))\r\n *\r\n * atanh(|x| > 1) = NaN\r\n * atanh(NaN) = NaN\r\n * atanh(Infinity) = NaN\r\n * atanh(-Infinity) = NaN\r\n * atanh(0) = 0\r\n * atanh(-0) = -0\r\n * atanh(1) = Infinity\r\n * atanh(-1) = -Infinity\r\n *\r\n */\r\n P.inverseHyperbolicTangent = P.atanh = function () {\r\n var pr, rm, wpr, xsd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n xsd = x.sd();\r\n\r\n if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);\r\n\r\n Ctor.precision = wpr = xsd - x.e;\r\n\r\n x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);\r\n\r\n Ctor.precision = pr + 4;\r\n Ctor.rounding = 1;\r\n\r\n x = x.ln();\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.times(0.5);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))\r\n *\r\n * asin(0) = 0\r\n * asin(-0) = -0\r\n * asin(1/2) = pi/6\r\n * asin(-1/2) = -pi/6\r\n * asin(1) = pi/2\r\n * asin(-1) = -pi/2\r\n * asin(|x| > 1) = NaN\r\n * asin(NaN) = NaN\r\n *\r\n * TODO? Compare performance of Taylor series.\r\n *\r\n */\r\n P.inverseSine = P.asin = function () {\r\n var halfPi, k,\r\n pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n k = x.abs().cmp(1);\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n if (k !== -1) {\r\n\r\n // |x| is 1\r\n if (k === 0) {\r\n halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n halfPi.s = x.s;\r\n return halfPi;\r\n }\r\n\r\n // |x| > 1 or x is NaN\r\n return new Ctor(NaN);\r\n }\r\n\r\n // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6\r\n\r\n Ctor.precision = pr + 6;\r\n Ctor.rounding = 1;\r\n\r\n x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.times(2);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n *\r\n * atan(0) = 0\r\n * atan(-0) = -0\r\n * atan(1) = pi/4\r\n * atan(-1) = -pi/4\r\n * atan(Infinity) = pi/2\r\n * atan(-Infinity) = -pi/2\r\n * atan(NaN) = NaN\r\n *\r\n */\r\n P.inverseTangent = P.atan = function () {\r\n var i, j, k, n, px, t, r, wpr, x2,\r\n x = this,\r\n Ctor = x.constructor,\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding;\r\n\r\n if (!x.isFinite()) {\r\n if (!x.s) return new Ctor(NaN);\r\n if (pr + 4 <= PI_PRECISION) {\r\n r = getPi(Ctor, pr + 4, rm).times(0.5);\r\n r.s = x.s;\r\n return r;\r\n }\r\n } else if (x.isZero()) {\r\n return new Ctor(x);\r\n } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {\r\n r = getPi(Ctor, pr + 4, rm).times(0.25);\r\n r.s = x.s;\r\n return r;\r\n }\r\n\r\n Ctor.precision = wpr = pr + 10;\r\n Ctor.rounding = 1;\r\n\r\n // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);\r\n\r\n // Argument reduction\r\n // Ensure |x| < 0.42\r\n // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))\r\n\r\n k = Math.min(28, wpr / LOG_BASE + 2 | 0);\r\n\r\n for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));\r\n\r\n external = false;\r\n\r\n j = Math.ceil(wpr / LOG_BASE);\r\n n = 1;\r\n x2 = x.times(x);\r\n r = new Ctor(x);\r\n px = x;\r\n\r\n // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n for (; i !== -1;) {\r\n px = px.times(x2);\r\n t = r.minus(px.div(n += 2));\r\n\r\n px = px.times(x2);\r\n r = t.plus(px.div(n += 2));\r\n\r\n if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);\r\n }\r\n\r\n if (k) r = r.times(2 << (k - 1));\r\n\r\n external = true;\r\n\r\n return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is a finite number, otherwise return false.\r\n *\r\n */\r\n P.isFinite = function () {\r\n return !!this.d;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is an integer, otherwise return false.\r\n *\r\n */\r\n P.isInteger = P.isInt = function () {\r\n return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is NaN, otherwise return false.\r\n *\r\n */\r\n P.isNaN = function () {\r\n return !this.s;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is negative, otherwise return false.\r\n *\r\n */\r\n P.isNegative = P.isNeg = function () {\r\n return this.s < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is positive, otherwise return false.\r\n *\r\n */\r\n P.isPositive = P.isPos = function () {\r\n return this.s > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is 0 or -0, otherwise return false.\r\n *\r\n */\r\n P.isZero = function () {\r\n return !!this.d && this.d[0] === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n *\r\n */\r\n P.lessThan = P.lt = function (y) {\r\n return this.cmp(y) < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.\r\n *\r\n */\r\n P.lessThanOrEqualTo = P.lte = function (y) {\r\n return this.cmp(y) < 1;\r\n };\r\n\r\n\r\n /*\r\n * Return the logarithm of the value of this Decimal to the specified base, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * If no base is specified, return log[10](arg).\r\n *\r\n * log[base](arg) = ln(arg) / ln(base)\r\n *\r\n * The result will always be correctly rounded if the base of the log is 10, and 'almost always'\r\n * otherwise:\r\n *\r\n * Depending on the rounding mode, the result may be incorrectly rounded if the first fifteen\r\n * rounding digits are [49]99999999999999 or [50]00000000000000. In that case, the maximum error\r\n * between the result and the correctly rounded result will be one ulp (unit in the last place).\r\n *\r\n * log[-b](a) = NaN\r\n * log[0](a) = NaN\r\n * log[1](a) = NaN\r\n * log[NaN](a) = NaN\r\n * log[Infinity](a) = NaN\r\n * log[b](0) = -Infinity\r\n * log[b](-0) = -Infinity\r\n * log[b](-a) = NaN\r\n * log[b](1) = 0\r\n * log[b](Infinity) = Infinity\r\n * log[b](NaN) = NaN\r\n *\r\n * [base] {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\n P.logarithm = P.log = function (base) {\r\n var isBase10, d, denominator, k, inf, num, sd, r,\r\n arg = this,\r\n Ctor = arg.constructor,\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding,\r\n guard = 5;\r\n\r\n // Default base is 10.\r\n if (base == null) {\r\n base = new Ctor(10);\r\n isBase10 = true;\r\n } else {\r\n base = new Ctor(base);\r\n d = base.d;\r\n\r\n // Return NaN if base is negative, or non-finite, or is 0 or 1.\r\n if (base.s < 0 || !d || !d[0] || base.eq(1)) return new Ctor(NaN);\r\n\r\n isBase10 = base.eq(10);\r\n }\r\n\r\n d = arg.d;\r\n\r\n // Is arg negative, non-finite, 0 or 1?\r\n if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {\r\n return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);\r\n }\r\n\r\n // The result will have a non-terminating decimal expansion if base is 10 and arg is not an\r\n // integer power of 10.\r\n if (isBase10) {\r\n if (d.length > 1) {\r\n inf = true;\r\n } else {\r\n for (k = d[0]; k % 10 === 0;) k /= 10;\r\n inf = k !== 1;\r\n }\r\n }\r\n\r\n external = false;\r\n sd = pr + guard;\r\n num = naturalLogarithm(arg, sd);\r\n denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n\r\n // The result will have 5 rounding digits.\r\n r = divide(num, denominator, sd, 1);\r\n\r\n // If at a rounding boundary, i.e. the result's rounding digits are [49]9999 or [50]0000,\r\n // calculate 10 further digits.\r\n //\r\n // If the result is known to have an infinite decimal expansion, repeat this until it is clear\r\n // that the result is above or below the boundary. Otherwise, if after calculating the 10\r\n // further digits, the last 14 are nines, round up and assume the result is exact.\r\n // Also assume the result is exact if the last 14 are zero.\r\n //\r\n // Example of a result that will be incorrectly rounded:\r\n // log[1048576](4503599627370502) = 2.60000000000000009610279511444746...\r\n // The above result correctly rounded using ROUND_CEIL to 1 decimal place should be 2.7, but it\r\n // will be given as 2.6 as there are 15 zeros immediately after the requested decimal place, so\r\n // the exact result would be assumed to be 2.6, which rounded using ROUND_CEIL to 1 decimal\r\n // place is still 2.6.\r\n if (checkRoundingDigits(r.d, k = pr, rm)) {\r\n\r\n do {\r\n sd += 10;\r\n num = naturalLogarithm(arg, sd);\r\n denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n r = divide(num, denominator, sd, 1);\r\n\r\n if (!inf) {\r\n\r\n // Check for 14 nines from the 2nd rounding digit, as the first may be 4.\r\n if (+digitsToString(r.d).slice(k + 1, k + 15) + 1 == 1e14) {\r\n r = finalise(r, pr + 1, 0);\r\n }\r\n\r\n break;\r\n }\r\n } while (checkRoundingDigits(r.d, k += 10, rm));\r\n }\r\n\r\n external = true;\r\n\r\n return finalise(r, pr, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the maximum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n P.max = function () {\r\n Array.prototype.push.call(arguments, this);\r\n return maxOrMin(this.constructor, arguments, 'lt');\r\n };\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the minimum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n P.min = function () {\r\n Array.prototype.push.call(arguments, this);\r\n return maxOrMin(this.constructor, arguments, 'gt');\r\n };\r\n */\r\n\r\n\r\n /*\r\n * n - 0 = n\r\n * n - N = N\r\n * n - I = -I\r\n * 0 - n = -n\r\n * 0 - 0 = 0\r\n * 0 - N = N\r\n * 0 - I = -I\r\n * N - n = N\r\n * N - 0 = N\r\n * N - N = N\r\n * N - I = N\r\n * I - n = I\r\n * I - 0 = I\r\n * I - N = N\r\n * I - I = N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.minus = P.sub = function (y) {\r\n var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // If either is not finite...\r\n if (!x.d || !y.d) {\r\n\r\n // Return NaN if either is NaN.\r\n if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n // Return y negated if x is finite and y is ±Infinity.\r\n else if (x.d) y.s = -y.s;\r\n\r\n // Return x if y is finite and x is ±Infinity.\r\n // Return x if both are ±Infinity with different signs.\r\n // Return NaN if both are ±Infinity with the same sign.\r\n else y = new Ctor(y.d || x.s !== y.s ? x : NaN);\r\n\r\n return y;\r\n }\r\n\r\n // If signs differ...\r\n if (x.s != y.s) {\r\n y.s = -y.s;\r\n return x.plus(y);\r\n }\r\n\r\n xd = x.d;\r\n yd = y.d;\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n // If either is zero...\r\n if (!xd[0] || !yd[0]) {\r\n\r\n // Return y negated if x is zero and y is non-zero.\r\n if (yd[0]) y.s = -y.s;\r\n\r\n // Return x if y is zero and x is non-zero.\r\n else if (xd[0]) y = new Ctor(x);\r\n\r\n // Return zero if both are zero.\r\n // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.\r\n else return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n }\r\n\r\n // x and y are finite, non-zero numbers with the same sign.\r\n\r\n // Calculate base 1e7 exponents.\r\n e = mathfloor(y.e / LOG_BASE);\r\n xe = mathfloor(x.e / LOG_BASE);\r\n\r\n xd = xd.slice();\r\n k = xe - e;\r\n\r\n // If base 1e7 exponents differ...\r\n if (k) {\r\n xLTy = k < 0;\r\n\r\n if (xLTy) {\r\n d = xd;\r\n k = -k;\r\n len = yd.length;\r\n } else {\r\n d = yd;\r\n e = xe;\r\n len = xd.length;\r\n }\r\n\r\n // Numbers with massively different exponents would result in a very high number of\r\n // zeros needing to be prepended, but this can be avoided while still ensuring correct\r\n // rounding by limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n if (k > i) {\r\n k = i;\r\n d.length = 1;\r\n }\r\n\r\n // Prepend zeros to equalise exponents.\r\n d.reverse();\r\n for (i = k; i--;) d.push(0);\r\n d.reverse();\r\n\r\n // Base 1e7 exponents equal.\r\n } else {\r\n\r\n // Check digits to determine which is the bigger number.\r\n\r\n i = xd.length;\r\n len = yd.length;\r\n xLTy = i < len;\r\n if (xLTy) len = i;\r\n\r\n for (i = 0; i < len; i++) {\r\n if (xd[i] != yd[i]) {\r\n xLTy = xd[i] < yd[i];\r\n break;\r\n }\r\n }\r\n\r\n k = 0;\r\n }\r\n\r\n if (xLTy) {\r\n d = xd;\r\n xd = yd;\r\n yd = d;\r\n y.s = -y.s;\r\n }\r\n\r\n len = xd.length;\r\n\r\n // Append zeros to `xd` if shorter.\r\n // Don't add zeros to `yd` if shorter as subtraction only needs to start at `yd` length.\r\n for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n // Subtract yd from xd.\r\n for (i = yd.length; i > k;) {\r\n\r\n if (xd[--i] < yd[i]) {\r\n for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n --xd[j];\r\n xd[i] += BASE;\r\n }\r\n\r\n xd[i] -= yd[i];\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (; xd[--len] === 0;) xd.pop();\r\n\r\n // Remove leading zeros and adjust exponent accordingly.\r\n for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n // Zero?\r\n if (!xd[0]) return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n y.d = xd;\r\n y.e = getBase10Exponent(xd, e);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n };\r\n\r\n\r\n /*\r\n * n % 0 = N\r\n * n % N = N\r\n * n % I = n\r\n * 0 % n = 0\r\n * -0 % n = -0\r\n * 0 % 0 = N\r\n * 0 % N = N\r\n * 0 % I = 0\r\n * N % n = N\r\n * N % 0 = N\r\n * N % N = N\r\n * N % I = N\r\n * I % n = N\r\n * I % 0 = N\r\n * I % N = N\r\n * I % I = N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal modulo `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * The result depends on the modulo mode.\r\n *\r\n */\r\n P.modulo = P.mod = function (y) {\r\n var q,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.\r\n if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);\r\n\r\n // Return x if y is ±Infinity or x is ±0.\r\n if (!y.d || x.d && !x.d[0]) {\r\n return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);\r\n }\r\n\r\n // Prevent rounding of intermediate calculations.\r\n external = false;\r\n\r\n if (Ctor.modulo == 9) {\r\n\r\n // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n // result = x - q * y where 0 <= result < abs(y)\r\n q = divide(x, y.abs(), 0, 3, 1);\r\n q.s *= y.s;\r\n } else {\r\n q = divide(x, y, 0, Ctor.modulo, 1);\r\n }\r\n\r\n q = q.times(y);\r\n\r\n external = true;\r\n\r\n return x.minus(q);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n * i.e. the base e raised to the power the value of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.naturalExponential = P.exp = function () {\r\n return naturalExponential(this);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.naturalLogarithm = P.ln = function () {\r\n return naturalLogarithm(this);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n * -1.\r\n *\r\n */\r\n P.negated = P.neg = function () {\r\n var x = new this.constructor(this);\r\n x.s = -x.s;\r\n return finalise(x);\r\n };\r\n\r\n\r\n /*\r\n * n + 0 = n\r\n * n + N = N\r\n * n + I = I\r\n * 0 + n = n\r\n * 0 + 0 = 0\r\n * 0 + N = N\r\n * 0 + I = I\r\n * N + n = N\r\n * N + 0 = N\r\n * N + N = N\r\n * N + I = N\r\n * I + n = I\r\n * I + 0 = I\r\n * I + N = N\r\n * I + I = I\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal plus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.plus = P.add = function (y) {\r\n var carry, d, e, i, k, len, pr, rm, xd, yd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // If either is not finite...\r\n if (!x.d || !y.d) {\r\n\r\n // Return NaN if either is NaN.\r\n if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n // Return x if y is finite and x is ±Infinity.\r\n // Return x if both are ±Infinity with the same sign.\r\n // Return NaN if both are ±Infinity with different signs.\r\n // Return y if x is finite and y is ±Infinity.\r\n else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);\r\n\r\n return y;\r\n }\r\n\r\n // If signs differ...\r\n if (x.s != y.s) {\r\n y.s = -y.s;\r\n return x.minus(y);\r\n }\r\n\r\n xd = x.d;\r\n yd = y.d;\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n // If either is zero...\r\n if (!xd[0] || !yd[0]) {\r\n\r\n // Return x if y is zero.\r\n // Return y if y is non-zero.\r\n if (!yd[0]) y = new Ctor(x);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n }\r\n\r\n // x and y are finite, non-zero numbers with the same sign.\r\n\r\n // Calculate base 1e7 exponents.\r\n k = mathfloor(x.e / LOG_BASE);\r\n e = mathfloor(y.e / LOG_BASE);\r\n\r\n xd = xd.slice();\r\n i = k - e;\r\n\r\n // If base 1e7 exponents differ...\r\n if (i) {\r\n\r\n if (i < 0) {\r\n d = xd;\r\n i = -i;\r\n len = yd.length;\r\n } else {\r\n d = yd;\r\n e = k;\r\n len = xd.length;\r\n }\r\n\r\n // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n k = Math.ceil(pr / LOG_BASE);\r\n len = k > len ? k + 1 : len + 1;\r\n\r\n if (i > len) {\r\n i = len;\r\n d.length = 1;\r\n }\r\n\r\n // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n d.reverse();\r\n for (; i--;) d.push(0);\r\n d.reverse();\r\n }\r\n\r\n len = xd.length;\r\n i = yd.length;\r\n\r\n // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n if (len - i < 0) {\r\n i = len;\r\n d = yd;\r\n yd = xd;\r\n xd = d;\r\n }\r\n\r\n // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n for (carry = 0; i;) {\r\n carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n xd[i] %= BASE;\r\n }\r\n\r\n if (carry) {\r\n xd.unshift(carry);\r\n ++e;\r\n }\r\n\r\n // Remove trailing zeros.\r\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n y.d = xd;\r\n y.e = getBase10Exponent(xd, e);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return the number of significant digits of the value of this Decimal.\r\n *\r\n * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n *\r\n */\r\n P.precision = P.sd = function (z) {\r\n var k,\r\n x = this;\r\n\r\n if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n if (x.d) {\r\n k = getPrecision(x.d);\r\n if (z && x.e + 1 > k) k = x.e + 1;\r\n } else {\r\n k = NaN;\r\n }\r\n\r\n return k;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n * rounding mode `rounding`.\r\n *\r\n */\r\n P.round = function () {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n return finalise(new Ctor(x), x.e + 1, Ctor.rounding);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n *\r\n * sin(0) = 0\r\n * sin(-0) = -0\r\n * sin(Infinity) = NaN\r\n * sin(-Infinity) = NaN\r\n * sin(NaN) = NaN\r\n *\r\n */\r\n P.sine = P.sin = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n Ctor.rounding = 1;\r\n\r\n x = sine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * sqrt(-n) = N\r\n * sqrt(N) = N\r\n * sqrt(-I) = N\r\n * sqrt(I) = I\r\n * sqrt(0) = 0\r\n * sqrt(-0) = -0\r\n *\r\n */\r\n P.squareRoot = P.sqrt = function () {\r\n var m, n, sd, r, rep, t,\r\n x = this,\r\n d = x.d,\r\n e = x.e,\r\n s = x.s,\r\n Ctor = x.constructor;\r\n\r\n // Negative/NaN/Infinity/zero?\r\n if (s !== 1 || !d || !d[0]) {\r\n return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);\r\n }\r\n\r\n external = false;\r\n\r\n // Initial estimate.\r\n s = Math.sqrt(+x);\r\n\r\n // Math.sqrt underflow/overflow?\r\n // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n if (s == 0 || s == 1 / 0) {\r\n n = digitsToString(d);\r\n\r\n if ((n.length + e) % 2 == 0) n += '0';\r\n s = Math.sqrt(n);\r\n e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n if (s == 1 / 0) {\r\n n = '5e' + e;\r\n } else {\r\n n = s.toExponential();\r\n n = n.slice(0, n.indexOf('e') + 1) + e;\r\n }\r\n\r\n r = new Ctor(n);\r\n } else {\r\n r = new Ctor(s.toString());\r\n }\r\n\r\n sd = (e = Ctor.precision) + 3;\r\n\r\n // Newton-Raphson iteration.\r\n for (;;) {\r\n t = r;\r\n r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);\r\n\r\n // TODO? Replace with for-loop and checkRoundingDigits.\r\n if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n n = n.slice(sd - 3, sd + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n // 4999, i.e. approaching a rounding boundary, continue the iteration.\r\n if (n == '9999' || !rep && n == '4999') {\r\n\r\n // On the first iteration only, check to see if rounding up gives the exact result as the\r\n // nines may infinitely repeat.\r\n if (!rep) {\r\n finalise(t, e + 1, 0);\r\n\r\n if (t.times(t).eq(x)) {\r\n r = t;\r\n break;\r\n }\r\n }\r\n\r\n sd += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n // If not, then there are further digits and m will be truthy.\r\n if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n // Truncate to the first rounding digit.\r\n finalise(r, e + 1, 1);\r\n m = !r.times(r).eq(x);\r\n }\r\n\r\n break;\r\n }\r\n }\r\n }\r\n\r\n external = true;\r\n\r\n return finalise(r, e, Ctor.rounding, m);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * tan(0) = 0\r\n * tan(-0) = -0\r\n * tan(Infinity) = NaN\r\n * tan(-Infinity) = NaN\r\n * tan(NaN) = NaN\r\n *\r\n */\r\n P.tangent = P.tan = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 10;\r\n Ctor.rounding = 1;\r\n\r\n x = x.sin();\r\n x.s = 1;\r\n x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n * n * 0 = 0\r\n * n * N = N\r\n * n * I = I\r\n * 0 * n = 0\r\n * 0 * 0 = 0\r\n * 0 * N = N\r\n * 0 * I = N\r\n * N * n = N\r\n * N * 0 = N\r\n * N * N = N\r\n * N * I = N\r\n * I * n = I\r\n * I * 0 = N\r\n * I * N = N\r\n * I * I = I\r\n *\r\n * Return a new Decimal whose value is this Decimal times `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.times = P.mul = function (y) {\r\n var carry, e, i, k, r, rL, t, xdL, ydL,\r\n x = this,\r\n Ctor = x.constructor,\r\n xd = x.d,\r\n yd = (y = new Ctor(y)).d;\r\n\r\n y.s *= x.s;\r\n\r\n // If either is NaN, ±Infinity or ±0...\r\n if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd\r\n\r\n // Return NaN if either is NaN.\r\n // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.\r\n ? NaN\r\n\r\n // Return ±Infinity if either is ±Infinity.\r\n // Return ±0 if either is ±0.\r\n : !xd || !yd ? y.s / 0 : y.s * 0);\r\n }\r\n\r\n e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);\r\n xdL = xd.length;\r\n ydL = yd.length;\r\n\r\n // Ensure xd points to the longer array.\r\n if (xdL < ydL) {\r\n r = xd;\r\n xd = yd;\r\n yd = r;\r\n rL = xdL;\r\n xdL = ydL;\r\n ydL = rL;\r\n }\r\n\r\n // Initialise the result array with zeros.\r\n r = [];\r\n rL = xdL + ydL;\r\n for (i = rL; i--;) r.push(0);\r\n\r\n // Multiply!\r\n for (i = ydL; --i >= 0;) {\r\n carry = 0;\r\n for (k = xdL + i; k > i;) {\r\n t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n r[k--] = t % BASE | 0;\r\n carry = t / BASE | 0;\r\n }\r\n\r\n r[k] = (r[k] + carry) % BASE | 0;\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (; !r[--rL];) r.pop();\r\n\r\n if (carry) ++e;\r\n else r.shift();\r\n\r\n y.d = r;\r\n y.e = getBase10Exponent(r, e);\r\n\r\n return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 2, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toBinary = function (sd, rm) {\r\n return toStringBinary(this, 2, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n *\r\n * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toDecimalPlaces = P.toDP = function (dp, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n x = new Ctor(x);\r\n if (dp === void 0) return x;\r\n\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n return finalise(x, dp + x.e + 1, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in exponential notation rounded to\r\n * `dp` fixed decimal places using rounding mode `rounding`.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toExponential = function (dp, rm) {\r\n var str,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (dp === void 0) {\r\n str = finiteToString(x, true);\r\n } else {\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n x = finalise(new Ctor(x), dp + 1, rm);\r\n str = finiteToString(x, true, dp + 1);\r\n }\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n * omitted.\r\n *\r\n * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n * (-0).toFixed(3) is '0.000'.\r\n * (-0.5).toFixed(0) is '-0'.\r\n *\r\n */\r\n P.toFixed = function (dp, rm) {\r\n var str, y,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (dp === void 0) {\r\n str = finiteToString(x);\r\n } else {\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n y = finalise(new Ctor(x), dp + x.e + 1, rm);\r\n str = finiteToString(y, false, dp + y.e + 1);\r\n }\r\n\r\n // To determine whether to add the minus sign look at the value before it was rounded,\r\n // i.e. look at `x` rather than `y`.\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return an array representing the value of this Decimal as a simple fraction with an integer\r\n * numerator and an integer denominator.\r\n *\r\n * The denominator will be a positive non-zero value less than or equal to the specified maximum\r\n * denominator. If a maximum denominator is not specified, the denominator will be the lowest\r\n * value necessary to represent the number exactly.\r\n *\r\n * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.\r\n *\r\n */\r\n P.toFraction = function (maxD) {\r\n var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,\r\n x = this,\r\n xd = x.d,\r\n Ctor = x.constructor;\r\n\r\n if (!xd) return new Ctor(x);\r\n\r\n n1 = d0 = new Ctor(1);\r\n d1 = n0 = new Ctor(0);\r\n\r\n d = new Ctor(d1);\r\n e = d.e = getPrecision(xd) - x.e - 1;\r\n k = e % LOG_BASE;\r\n d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);\r\n\r\n if (maxD == null) {\r\n\r\n // d is 10**e, the minimum max-denominator needed.\r\n maxD = e > 0 ? d : n1;\r\n } else {\r\n n = new Ctor(maxD);\r\n if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);\r\n maxD = n.gt(d) ? (e > 0 ? d : n1) : n;\r\n }\r\n\r\n external = false;\r\n n = new Ctor(digitsToString(xd));\r\n pr = Ctor.precision;\r\n Ctor.precision = e = xd.length * LOG_BASE * 2;\r\n\r\n for (;;) {\r\n q = divide(n, d, 0, 1, 1);\r\n d2 = d0.plus(q.times(d1));\r\n if (d2.cmp(maxD) == 1) break;\r\n d0 = d1;\r\n d1 = d2;\r\n d2 = n1;\r\n n1 = n0.plus(q.times(d2));\r\n n0 = d2;\r\n d2 = d;\r\n d = n.minus(q.times(d2));\r\n n = d2;\r\n }\r\n\r\n d2 = divide(maxD.minus(d0), d1, 0, 1, 1);\r\n n0 = n0.plus(d2.times(n1));\r\n d0 = d0.plus(d2.times(d1));\r\n n0.s = n1.s = x.s;\r\n\r\n // Determine which fraction is closer to x, n0/d0 or n1/d1?\r\n r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1\r\n ? [n1, d1] : [n0, d0];\r\n\r\n Ctor.precision = pr;\r\n external = true;\r\n\r\n return r;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 16, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toHexadecimal = P.toHex = function (sd, rm) {\r\n return toStringBinary(this, 16, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding\r\n * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.\r\n *\r\n * The return value will always have the same sign as this Decimal, unless either this Decimal\r\n * or `y` is NaN, in which case the return value will be also be NaN.\r\n *\r\n * The return value is not affected by the value of `precision`.\r\n *\r\n * y {number|string|Decimal} The magnitude to round to a multiple of.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toNearest() rounding mode not an integer: {rm}'\r\n * 'toNearest() rounding mode out of range: {rm}'\r\n *\r\n */\r\n P.toNearest = function (y, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n x = new Ctor(x);\r\n\r\n if (y == null) {\r\n\r\n // If x is not finite, return x.\r\n if (!x.d) return x;\r\n\r\n y = new Ctor(1);\r\n rm = Ctor.rounding;\r\n } else {\r\n y = new Ctor(y);\r\n if (rm === void 0) {\r\n rm = Ctor.rounding;\r\n } else {\r\n checkInt32(rm, 0, 8);\r\n }\r\n\r\n // If x is not finite, return x if y is not NaN, else NaN.\r\n if (!x.d) return y.s ? x : y;\r\n\r\n // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.\r\n if (!y.d) {\r\n if (y.s) y.s = x.s;\r\n return y;\r\n }\r\n }\r\n\r\n // If y is not zero, calculate the nearest multiple of y to x.\r\n if (y.d[0]) {\r\n external = false;\r\n x = divide(x, y, 0, rm, 1).times(y);\r\n external = true;\r\n finalise(x);\r\n\r\n // If y is zero, return zero with the sign of x.\r\n } else {\r\n y.s = x.s;\r\n x = y;\r\n }\r\n\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * Return the value of this Decimal converted to a number primitive.\r\n * Zero keeps its sign.\r\n *\r\n */\r\n P.toNumber = function () {\r\n return +this;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 8, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toOctal = function (sd, rm) {\r\n return toStringBinary(this, 8, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal raised to the power `y`, rounded\r\n * to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * ECMAScript compliant.\r\n *\r\n * pow(x, NaN) = NaN\r\n * pow(x, ±0) = 1\r\n\r\n * pow(NaN, non-zero) = NaN\r\n * pow(abs(x) > 1, +Infinity) = +Infinity\r\n * pow(abs(x) > 1, -Infinity) = +0\r\n * pow(abs(x) == 1, ±Infinity) = NaN\r\n * pow(abs(x) < 1, +Infinity) = +0\r\n * pow(abs(x) < 1, -Infinity) = +Infinity\r\n * pow(+Infinity, y > 0) = +Infinity\r\n * pow(+Infinity, y < 0) = +0\r\n * pow(-Infinity, odd integer > 0) = -Infinity\r\n * pow(-Infinity, even integer > 0) = +Infinity\r\n * pow(-Infinity, odd integer < 0) = -0\r\n * pow(-Infinity, even integer < 0) = +0\r\n * pow(+0, y > 0) = +0\r\n * pow(+0, y < 0) = +Infinity\r\n * pow(-0, odd integer > 0) = -0\r\n * pow(-0, even integer > 0) = +0\r\n * pow(-0, odd integer < 0) = -Infinity\r\n * pow(-0, even integer < 0) = +Infinity\r\n * pow(finite x < 0, finite non-integer) = NaN\r\n *\r\n * For non-integer or very large exponents pow(x, y) is calculated using\r\n *\r\n * x^y = exp(y*ln(x))\r\n *\r\n * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the\r\n * probability of an incorrectly rounded result\r\n * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14\r\n * i.e. 1 in 250,000,000,000,000\r\n *\r\n * If a result is incorrectly rounded the maximum error will be 1 ulp (unit in last place).\r\n *\r\n * y {number|string|Decimal} The power to which to raise this Decimal.\r\n *\r\n */\r\n P.toPower = P.pow = function (y) {\r\n var e, k, pr, r, rm, s,\r\n x = this,\r\n Ctor = x.constructor,\r\n yn = +(y = new Ctor(y));\r\n\r\n // Either ±Infinity, NaN or ±0?\r\n if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));\r\n\r\n x = new Ctor(x);\r\n\r\n if (x.eq(1)) return x;\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n if (y.eq(1)) return finalise(x, pr, rm);\r\n\r\n // y exponent\r\n e = mathfloor(y.e / LOG_BASE);\r\n\r\n // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n r = intPow(Ctor, x, k, pr);\r\n return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);\r\n }\r\n\r\n s = x.s;\r\n\r\n // if x is negative\r\n if (s < 0) {\r\n\r\n // if y is not an integer\r\n if (e < y.d.length - 1) return new Ctor(NaN);\r\n\r\n // Result is positive if x is negative and the last digit of integer y is even.\r\n if ((y.d[e] & 1) == 0) s = 1;\r\n\r\n // if x.eq(-1)\r\n if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {\r\n x.s = s;\r\n return x;\r\n }\r\n }\r\n\r\n // Estimate result exponent.\r\n // x^y = 10^e, where e = y * log10(x)\r\n // log10(x) = log10(x_significand) + x_exponent\r\n // log10(x_significand) = ln(x_significand) / ln(10)\r\n k = mathpow(+x, yn);\r\n e = k == 0 || !isFinite(k)\r\n ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))\r\n : new Ctor(k + '').e;\r\n\r\n // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.\r\n\r\n // Overflow/underflow?\r\n if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);\r\n\r\n external = false;\r\n Ctor.rounding = x.s = 1;\r\n\r\n // Estimate the extra guard digits needed to ensure five correct rounding digits from\r\n // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):\r\n // new Decimal(2.32456).pow('2087987436534566.46411')\r\n // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815\r\n k = Math.min(12, (e + '').length);\r\n\r\n // r = x^y = exp(y*ln(x))\r\n r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);\r\n\r\n // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)\r\n if (r.d) {\r\n\r\n // Truncate to the required precision plus five rounding digits.\r\n r = finalise(r, pr + 5, 1);\r\n\r\n // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate\r\n // the result.\r\n if (checkRoundingDigits(r.d, pr, rm)) {\r\n e = pr + 10;\r\n\r\n // Truncate to the increased precision plus five rounding digits.\r\n r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);\r\n\r\n // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).\r\n if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {\r\n r = finalise(r, pr + 1, 0);\r\n }\r\n }\r\n }\r\n\r\n r.s = s;\r\n external = true;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(r, pr, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * Return exponential notation if `sd` is less than the number of digits necessary to represent\r\n * the integer part of the value in normal notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toPrecision = function (sd, rm) {\r\n var str,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (sd === void 0) {\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n } else {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n x = finalise(new Ctor(x), sd, rm);\r\n str = finiteToString(x, sd <= x.e || x.e <= Ctor.toExpNeg, sd);\r\n }\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n * omitted.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toSD() digits out of range: {sd}'\r\n * 'toSD() digits not an integer: {sd}'\r\n * 'toSD() rounding mode not an integer: {rm}'\r\n * 'toSD() rounding mode out of range: {rm}'\r\n *\r\n */\r\n P.toSignificantDigits = P.toSD = function (sd, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n if (sd === void 0) {\r\n sd = Ctor.precision;\r\n rm = Ctor.rounding;\r\n } else {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n }\r\n\r\n return finalise(new Ctor(x), sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal.\r\n *\r\n * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n *\r\n */\r\n P.toString = function () {\r\n var x = this,\r\n Ctor = x.constructor,\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal truncated to a whole number.\r\n *\r\n */\r\n P.truncated = P.trunc = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal.\r\n * Unlike `toString`, negative zero will include the minus sign.\r\n *\r\n */\r\n P.valueOf = P.toJSON = function () {\r\n var x = this,\r\n Ctor = x.constructor,\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n return x.isNeg() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n // Add aliases to match BigDecimal method names.\r\n // P.add = P.plus;\r\n P.subtract = P.minus;\r\n P.multiply = P.times;\r\n P.divide = P.div;\r\n P.remainder = P.mod;\r\n P.compareTo = P.cmp;\r\n P.negate = P.neg;\r\n */\r\n\r\n\r\n // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n /*\r\n * digitsToString P.cubeRoot, P.logarithm, P.squareRoot, P.toFraction, P.toPower,\r\n * finiteToString, naturalExponential, naturalLogarithm\r\n * checkInt32 P.toDecimalPlaces, P.toExponential, P.toFixed, P.toNearest,\r\n * P.toPrecision, P.toSignificantDigits, toStringBinary, random\r\n * checkRoundingDigits P.logarithm, P.toPower, naturalExponential, naturalLogarithm\r\n * convertBase toStringBinary, parseOther\r\n * cos P.cos\r\n * divide P.atanh, P.cubeRoot, P.dividedBy, P.dividedToIntegerBy,\r\n * P.logarithm, P.modulo, P.squareRoot, P.tan, P.tanh, P.toFraction,\r\n * P.toNearest, toStringBinary, naturalExponential, naturalLogarithm,\r\n * taylorSeries, atan2, parseOther\r\n * finalise P.absoluteValue, P.atan, P.atanh, P.ceil, P.cos, P.cosh,\r\n * P.cubeRoot, P.dividedToIntegerBy, P.floor, P.logarithm, P.minus,\r\n * P.modulo, P.negated, P.plus, P.round, P.sin, P.sinh, P.squareRoot,\r\n * P.tan, P.times, P.toDecimalPlaces, P.toExponential, P.toFixed,\r\n * P.toNearest, P.toPower, P.toPrecision, P.toSignificantDigits,\r\n * P.truncated, divide, getLn10, getPi, naturalExponential,\r\n * naturalLogarithm, ceil, floor, round, trunc\r\n * finiteToString P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf,\r\n * toStringBinary\r\n * getBase10Exponent P.minus, P.plus, P.times, parseOther\r\n * getLn10 P.logarithm, naturalLogarithm\r\n * getPi P.acos, P.asin, P.atan, toLessThanHalfPi, atan2\r\n * getPrecision P.precision, P.toFraction\r\n * getZeroString digitsToString, finiteToString\r\n * intPow P.toPower, parseOther\r\n * isOdd toLessThanHalfPi\r\n * maxOrMin max, min\r\n * naturalExponential P.naturalExponential, P.toPower\r\n * naturalLogarithm P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,\r\n * P.toPower, naturalExponential\r\n * nonFiniteToString finiteToString, toStringBinary\r\n * parseDecimal Decimal\r\n * parseOther Decimal\r\n * sin P.sin\r\n * taylorSeries P.cosh, P.sinh, cos, sin\r\n * toLessThanHalfPi P.cos, P.sin\r\n * toStringBinary P.toBinary, P.toHexadecimal, P.toOctal\r\n * truncate intPow\r\n *\r\n * Throws: P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,\r\n * naturalLogarithm, config, parseOther, random, Decimal\r\n */\r\n\r\n\r\n function digitsToString(d) {\r\n var i, k, ws,\r\n indexOfLastWord = d.length - 1,\r\n str = '',\r\n w = d[0];\r\n\r\n if (indexOfLastWord > 0) {\r\n str += w;\r\n for (i = 1; i < indexOfLastWord; i++) {\r\n ws = d[i] + '';\r\n k = LOG_BASE - ws.length;\r\n if (k) str += getZeroString(k);\r\n str += ws;\r\n }\r\n\r\n w = d[i];\r\n ws = w + '';\r\n k = LOG_BASE - ws.length;\r\n if (k) str += getZeroString(k);\r\n } else if (w === 0) {\r\n return '0';\r\n }\r\n\r\n // Remove trailing zeros of last w.\r\n for (; w % 10 === 0;) w /= 10;\r\n\r\n return str + w;\r\n }\r\n\r\n\r\n function checkInt32(i, min, max) {\r\n if (i !== ~~i || i < min || i > max) {\r\n throw Error(invalidArgument + i);\r\n }\r\n }\r\n\r\n\r\n /*\r\n * Check 5 rounding digits if `repeating` is null, 4 otherwise.\r\n * `repeating == null` if caller is `log` or `pow`,\r\n * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.\r\n */\r\n function checkRoundingDigits(d, i, rm, repeating) {\r\n var di, k, r, rd;\r\n\r\n // Get the length of the first word of the array d.\r\n for (k = d[0]; k >= 10; k /= 10) --i;\r\n\r\n // Is the rounding digit in the first word of d?\r\n if (--i < 0) {\r\n i += LOG_BASE;\r\n di = 0;\r\n } else {\r\n di = Math.ceil((i + 1) / LOG_BASE);\r\n i %= LOG_BASE;\r\n }\r\n\r\n // i is the index (0 - 6) of the rounding digit.\r\n // E.g. if within the word 3487563 the first rounding digit is 5,\r\n // then i = 4, k = 1000, rd = 3487563 % 1000 = 563\r\n k = mathpow(10, LOG_BASE - i);\r\n rd = d[di] % k | 0;\r\n\r\n if (repeating == null) {\r\n if (i < 3) {\r\n if (i == 0) rd = rd / 100 | 0;\r\n else if (i == 1) rd = rd / 10 | 0;\r\n r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;\r\n } else {\r\n r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&\r\n (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||\r\n (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;\r\n }\r\n } else {\r\n if (i < 4) {\r\n if (i == 0) rd = rd / 1000 | 0;\r\n else if (i == 1) rd = rd / 100 | 0;\r\n else if (i == 2) rd = rd / 10 | 0;\r\n r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;\r\n } else {\r\n r = ((repeating || rm < 4) && rd + 1 == k ||\r\n (!repeating && rm > 3) && rd + 1 == k / 2) &&\r\n (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;\r\n }\r\n }\r\n\r\n return r;\r\n }\r\n\r\n\r\n // Convert string of `baseIn` to an array of numbers of `baseOut`.\r\n // Eg. convertBase('255', 10, 16) returns [15, 15].\r\n // Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\n function convertBase(str, baseIn, baseOut) {\r\n var j,\r\n arr = [0],\r\n arrL,\r\n i = 0,\r\n strL = str.length;\r\n\r\n for (; i < strL;) {\r\n for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;\r\n arr[0] += NUMERALS.indexOf(str.charAt(i++));\r\n for (j = 0; j < arr.length; j++) {\r\n if (arr[j] > baseOut - 1) {\r\n if (arr[j + 1] === void 0) arr[j + 1] = 0;\r\n arr[j + 1] += arr[j] / baseOut | 0;\r\n arr[j] %= baseOut;\r\n }\r\n }\r\n }\r\n\r\n return arr.reverse();\r\n }\r\n\r\n\r\n /*\r\n * cos(x) = 1 - x^2/2! + x^4/4! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\n function cosine(Ctor, x) {\r\n var k, y,\r\n len = x.d.length;\r\n\r\n // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1\r\n // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n if (len < 32) {\r\n k = Math.ceil(len / 3);\r\n y = (1 / tinyPow(4, k)).toString();\r\n } else {\r\n k = 16;\r\n y = '2.3283064365386962890625e-10';\r\n }\r\n\r\n Ctor.precision += k;\r\n\r\n x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));\r\n\r\n // Reverse argument reduction\r\n for (var i = k; i--;) {\r\n var cos2x = x.times(x);\r\n x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);\r\n }\r\n\r\n Ctor.precision -= k;\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Perform division in the specified base.\r\n */\r\n var divide = (function () {\r\n\r\n // Assumes non-zero x and k, and hence non-zero result.\r\n function multiplyInteger(x, k, base) {\r\n var temp,\r\n carry = 0,\r\n i = x.length;\r\n\r\n for (x = x.slice(); i--;) {\r\n temp = x[i] * k + carry;\r\n x[i] = temp % base | 0;\r\n carry = temp / base | 0;\r\n }\r\n\r\n if (carry) x.unshift(carry);\r\n\r\n return x;\r\n }\r\n\r\n function compare(a, b, aL, bL) {\r\n var i, r;\r\n\r\n if (aL != bL) {\r\n r = aL > bL ? 1 : -1;\r\n } else {\r\n for (i = r = 0; i < aL; i++) {\r\n if (a[i] != b[i]) {\r\n r = a[i] > b[i] ? 1 : -1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n return r;\r\n }\r\n\r\n function subtract(a, b, aL, base) {\r\n var i = 0;\r\n\r\n // Subtract b from a.\r\n for (; aL--;) {\r\n a[aL] -= i;\r\n i = a[aL] < b[aL] ? 1 : 0;\r\n a[aL] = i * base + a[aL] - b[aL];\r\n }\r\n\r\n // Remove leading zeros.\r\n for (; !a[0] && a.length > 1;) a.shift();\r\n }\r\n\r\n return function (x, y, pr, rm, dp, base) {\r\n var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,\r\n yL, yz,\r\n Ctor = x.constructor,\r\n sign = x.s == y.s ? 1 : -1,\r\n xd = x.d,\r\n yd = y.d;\r\n\r\n // Either NaN, Infinity or 0?\r\n if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n return new Ctor(// Return NaN if either NaN, or both Infinity or 0.\r\n !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :\r\n\r\n // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.\r\n xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);\r\n }\r\n\r\n if (base) {\r\n logBase = 1;\r\n e = x.e - y.e;\r\n } else {\r\n base = BASE;\r\n logBase = LOG_BASE;\r\n e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);\r\n }\r\n\r\n yL = yd.length;\r\n xL = xd.length;\r\n q = new Ctor(sign);\r\n qd = q.d = [];\r\n\r\n // Result exponent may be one less than e.\r\n // The digit array of a Decimal from toStringBinary may have trailing zeros.\r\n for (i = 0; yd[i] == (xd[i] || 0); i++);\r\n\r\n if (yd[i] > (xd[i] || 0)) e--;\r\n\r\n if (pr == null) {\r\n sd = pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n } else if (dp) {\r\n sd = pr + (x.e - y.e) + 1;\r\n } else {\r\n sd = pr;\r\n }\r\n\r\n if (sd < 0) {\r\n qd.push(1);\r\n more = true;\r\n } else {\r\n\r\n // Convert precision in number of base 10 digits to base 1e7 digits.\r\n sd = sd / logBase + 2 | 0;\r\n i = 0;\r\n\r\n // divisor < 1e7\r\n if (yL == 1) {\r\n k = 0;\r\n yd = yd[0];\r\n sd++;\r\n\r\n // k is the carry.\r\n for (; (i < xL || k) && sd--; i++) {\r\n t = k * base + (xd[i] || 0);\r\n qd[i] = t / yd | 0;\r\n k = t % yd | 0;\r\n }\r\n\r\n more = k || i < xL;\r\n\r\n // divisor >= 1e7\r\n } else {\r\n\r\n // Normalise xd and yd so highest order digit of yd is >= base/2\r\n k = base / (yd[0] + 1) | 0;\r\n\r\n if (k > 1) {\r\n yd = multiplyInteger(yd, k, base);\r\n xd = multiplyInteger(xd, k, base);\r\n yL = yd.length;\r\n xL = xd.length;\r\n }\r\n\r\n xi = yL;\r\n rem = xd.slice(0, yL);\r\n remL = rem.length;\r\n\r\n // Add zeros to make remainder as long as divisor.\r\n for (; remL < yL;) rem[remL++] = 0;\r\n\r\n yz = yd.slice();\r\n yz.unshift(0);\r\n yd0 = yd[0];\r\n\r\n if (yd[1] >= base / 2) ++yd0;\r\n\r\n do {\r\n k = 0;\r\n\r\n // Compare divisor and remainder.\r\n cmp = compare(yd, rem, yL, remL);\r\n\r\n // If divisor < remainder.\r\n if (cmp < 0) {\r\n\r\n // Calculate trial digit, k.\r\n rem0 = rem[0];\r\n if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n // k will be how many times the divisor goes into the current remainder.\r\n k = rem0 / yd0 | 0;\r\n\r\n // Algorithm:\r\n // 1. product = divisor * trial digit (k)\r\n // 2. if product > remainder: product -= divisor, k--\r\n // 3. remainder -= product\r\n // 4. if product was < remainder at 2:\r\n // 5. compare new remainder and divisor\r\n // 6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n if (k > 1) {\r\n if (k >= base) k = base - 1;\r\n\r\n // product = divisor * trial digit.\r\n prod = multiplyInteger(yd, k, base);\r\n prodL = prod.length;\r\n remL = rem.length;\r\n\r\n // Compare product and remainder.\r\n cmp = compare(prod, rem, prodL, remL);\r\n\r\n // product > remainder.\r\n if (cmp == 1) {\r\n k--;\r\n\r\n // Subtract divisor from product.\r\n subtract(prod, yL < prodL ? yz : yd, prodL, base);\r\n }\r\n } else {\r\n\r\n // cmp is -1.\r\n // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n if (k == 0) cmp = k = 1;\r\n prod = yd.slice();\r\n }\r\n\r\n prodL = prod.length;\r\n if (prodL < remL) prod.unshift(0);\r\n\r\n // Subtract product from remainder.\r\n subtract(rem, prod, remL, base);\r\n\r\n // If product was < previous remainder.\r\n if (cmp == -1) {\r\n remL = rem.length;\r\n\r\n // Compare divisor and new remainder.\r\n cmp = compare(yd, rem, yL, remL);\r\n\r\n // If divisor < new remainder, subtract divisor from remainder.\r\n if (cmp < 1) {\r\n k++;\r\n\r\n // Subtract divisor from remainder.\r\n subtract(rem, yL < remL ? yz : yd, remL, base);\r\n }\r\n }\r\n\r\n remL = rem.length;\r\n } else if (cmp === 0) {\r\n k++;\r\n rem = [0];\r\n } // if cmp === 1, k will be 0\r\n\r\n // Add the next digit, k, to the result array.\r\n qd[i++] = k;\r\n\r\n // Update the remainder.\r\n if (cmp && rem[0]) {\r\n rem[remL++] = xd[xi] || 0;\r\n } else {\r\n rem = [xd[xi]];\r\n remL = 1;\r\n }\r\n\r\n } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n\r\n more = rem[0] !== void 0;\r\n }\r\n\r\n // Leading zero?\r\n if (!qd[0]) qd.shift();\r\n }\r\n\r\n // logBase is 1 when divide is being used for base conversion.\r\n if (logBase == 1) {\r\n q.e = e;\r\n inexact = more;\r\n } else {\r\n\r\n // To calculate q.e, first get the number of digits of qd[0].\r\n for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;\r\n q.e = i + e * logBase - 1;\r\n\r\n finalise(q, dp ? pr + q.e + 1 : pr, rm, more);\r\n }\r\n\r\n return q;\r\n };\r\n })();\r\n\r\n\r\n /*\r\n * Round `x` to `sd` significant digits using rounding mode `rm`.\r\n * Check for over/under-flow.\r\n */\r\n function finalise(x, sd, rm, isTruncated) {\r\n var digits, i, j, k, rd, roundUp, w, xd, xdi,\r\n Ctor = x.constructor;\r\n\r\n // Don't round if sd is null or undefined.\r\n out: if (sd != null) {\r\n xd = x.d;\r\n\r\n // Infinity/NaN.\r\n if (!xd) return x;\r\n\r\n // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n // w: the word of xd containing rd, a base 1e7 number.\r\n // xdi: the index of w within xd.\r\n // digits: the number of digits of w.\r\n // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n // they had leading zeros)\r\n // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n // Get the length of the first word of the digits array xd.\r\n for (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;\r\n i = sd - digits;\r\n\r\n // Is the rounding digit in the first word of xd?\r\n if (i < 0) {\r\n i += LOG_BASE;\r\n j = sd;\r\n w = xd[xdi = 0];\r\n\r\n // Get the rounding digit at index j of w.\r\n rd = w / mathpow(10, digits - j - 1) % 10 | 0;\r\n } else {\r\n xdi = Math.ceil((i + 1) / LOG_BASE);\r\n k = xd.length;\r\n if (xdi >= k) {\r\n if (isTruncated) {\r\n\r\n // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.\r\n for (; k++ <= xdi;) xd.push(0);\r\n w = rd = 0;\r\n digits = 1;\r\n i %= LOG_BASE;\r\n j = i - LOG_BASE + 1;\r\n } else {\r\n break out;\r\n }\r\n } else {\r\n w = k = xd[xdi];\r\n\r\n // Get the number of digits of w.\r\n for (digits = 1; k >= 10; k /= 10) digits++;\r\n\r\n // Get the index of rd within w.\r\n i %= LOG_BASE;\r\n\r\n // Get the index of rd within w, adjusted for leading zeros.\r\n // The number of leading zeros of w is given by LOG_BASE - digits.\r\n j = i - LOG_BASE + digits;\r\n\r\n // Get the rounding digit at index j of w.\r\n rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;\r\n }\r\n }\r\n\r\n // Are there any non-zero digits after the rounding digit?\r\n isTruncated = isTruncated || sd < 0 ||\r\n xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));\r\n\r\n // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right\r\n // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression\r\n // will give 714.\r\n\r\n roundUp = rm < 4\r\n ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : rd > 5 || rd == 5 && (rm == 4 || isTruncated || rm == 6 &&\r\n\r\n // Check whether the digit to the left of the rounding digit is odd.\r\n ((i > 0 ? j > 0 ? w / mathpow(10, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n if (sd < 1 || !xd[0]) {\r\n xd.length = 0;\r\n if (roundUp) {\r\n\r\n // Convert sd to decimal places.\r\n sd -= x.e + 1;\r\n\r\n // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n x.e = -sd || 0;\r\n } else {\r\n\r\n // Zero.\r\n xd[0] = x.e = 0;\r\n }\r\n\r\n return x;\r\n }\r\n\r\n // Remove excess digits.\r\n if (i == 0) {\r\n xd.length = xdi;\r\n k = 1;\r\n xdi--;\r\n } else {\r\n xd.length = xdi + 1;\r\n k = mathpow(10, LOG_BASE - i);\r\n\r\n // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n // j > 0 means i > number of leading zeros of w.\r\n xd[xdi] = j > 0 ? (w / mathpow(10, digits - j) % mathpow(10, j) | 0) * k : 0;\r\n }\r\n\r\n if (roundUp) {\r\n for (;;) {\r\n\r\n // Is the digit to be rounded up in the first word of xd?\r\n if (xdi == 0) {\r\n\r\n // i will be the length of xd[0] before k is added.\r\n for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;\r\n j = xd[0] += k;\r\n for (k = 1; j >= 10; j /= 10) k++;\r\n\r\n // if i != k the length has increased.\r\n if (i != k) {\r\n x.e++;\r\n if (xd[0] == BASE) xd[0] = 1;\r\n }\r\n\r\n break;\r\n } else {\r\n xd[xdi] += k;\r\n if (xd[xdi] != BASE) break;\r\n xd[xdi--] = 0;\r\n k = 1;\r\n }\r\n }\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n }\r\n\r\n if (external) {\r\n\r\n // Overflow?\r\n if (x.e > Ctor.maxE) {\r\n\r\n // Infinity.\r\n x.d = null;\r\n x.e = NaN;\r\n\r\n // Underflow?\r\n } else if (x.e < Ctor.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n // Ctor.underflow = true;\r\n } // else Ctor.underflow = false;\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n function finiteToString(x, isExp, sd) {\r\n if (!x.isFinite()) return nonFiniteToString(x);\r\n var k,\r\n e = x.e,\r\n str = digitsToString(x.d),\r\n len = str.length;\r\n\r\n if (isExp) {\r\n if (sd && (k = sd - len) > 0) {\r\n str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n } else if (len > 1) {\r\n str = str.charAt(0) + '.' + str.slice(1);\r\n }\r\n\r\n str = str + (x.e < 0 ? 'e' : 'e+') + x.e;\r\n } else if (e < 0) {\r\n str = '0.' + getZeroString(-e - 1) + str;\r\n if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n } else if (e >= len) {\r\n str += getZeroString(e + 1 - len);\r\n if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n } else {\r\n if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n if (sd && (k = sd - len) > 0) {\r\n if (e + 1 === len) str += '.';\r\n str += getZeroString(k);\r\n }\r\n }\r\n\r\n return str;\r\n }\r\n\r\n\r\n // Calculate the base 10 exponent from the base 1e7 exponent.\r\n function getBase10Exponent(digits, e) {\r\n var w = digits[0];\r\n\r\n // Add the number of digits of the first word of the digits array.\r\n for ( e *= LOG_BASE; w >= 10; w /= 10) e++;\r\n return e;\r\n }\r\n\r\n\r\n function getLn10(Ctor, sd, pr) {\r\n if (sd > LN10_PRECISION) {\r\n\r\n // Reset global state in case the exception is caught.\r\n external = true;\r\n if (pr) Ctor.precision = pr;\r\n throw Error(precisionLimitExceeded);\r\n }\r\n return finalise(new Ctor(LN10), sd, 1, true);\r\n }\r\n\r\n\r\n function getPi(Ctor, sd, rm) {\r\n if (sd > PI_PRECISION) throw Error(precisionLimitExceeded);\r\n return finalise(new Ctor(PI), sd, rm, true);\r\n }\r\n\r\n\r\n function getPrecision(digits) {\r\n var w = digits.length - 1,\r\n len = w * LOG_BASE + 1;\r\n\r\n w = digits[w];\r\n\r\n // If non-zero...\r\n if (w) {\r\n\r\n // Subtract the number of trailing zeros of the last word.\r\n for (; w % 10 == 0; w /= 10) len--;\r\n\r\n // Add the number of digits of the first word.\r\n for (w = digits[0]; w >= 10; w /= 10) len++;\r\n }\r\n\r\n return len;\r\n }\r\n\r\n\r\n function getZeroString(k) {\r\n var zs = '';\r\n for (; k--;) zs += '0';\r\n return zs;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of Decimal `x` to the power `n`, where `n` is an\r\n * integer of type number.\r\n *\r\n * Implements 'exponentiation by squaring'. Called by `pow` and `parseOther`.\r\n *\r\n */\r\n function intPow(Ctor, x, n, pr) {\r\n var isTruncated,\r\n r = new Ctor(1),\r\n\r\n // Max n of 9007199254740991 takes 53 loop iterations.\r\n // Maximum digits array length; leaves [28, 34] guard digits.\r\n k = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n external = false;\r\n\r\n for (;;) {\r\n if (n % 2) {\r\n r = r.times(x);\r\n if (truncate(r.d, k)) isTruncated = true;\r\n }\r\n\r\n n = mathfloor(n / 2);\r\n if (n === 0) {\r\n\r\n // To ensure correct rounding when r.d is truncated, increment the last word if it is zero.\r\n n = r.d.length - 1;\r\n if (isTruncated && r.d[n] === 0) ++r.d[n];\r\n break;\r\n }\r\n\r\n x = x.times(x);\r\n truncate(x.d, k);\r\n }\r\n\r\n external = true;\r\n\r\n return r;\r\n }\r\n\r\n\r\n function isOdd(n) {\r\n return n.d[n.d.length - 1] & 1;\r\n }\r\n\r\n\r\n /*\r\n * Handle `max` and `min`. `ltgt` is 'lt' or 'gt'.\r\n */\r\n function maxOrMin(Ctor, args, ltgt) {\r\n var y,\r\n x = new Ctor(args[0]),\r\n i = 0;\r\n\r\n for (; ++i < args.length;) {\r\n y = new Ctor(args[i]);\r\n if (!y.s) {\r\n x = y;\r\n break;\r\n } else if (x[ltgt](y)) {\r\n x = y;\r\n }\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n * Taylor/Maclaurin series.\r\n *\r\n * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n *\r\n * Argument reduction:\r\n * Repeat x = x / 32, k += 5, until |x| < 0.1\r\n * exp(x) = exp(x / 2^k)^(2^k)\r\n *\r\n * Previously, the argument was initially reduced by\r\n * exp(x) = exp(r) * 10^k where r = x - k * ln10, k = floor(x / ln10)\r\n * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n * found to be slower than just dividing repeatedly by 32 as above.\r\n *\r\n * Max integer argument: exp('20723265836946413') = 6.3e+9000000000000000\r\n * Min integer argument: exp('-20723265836946411') = 1.2e-9000000000000000\r\n * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n *\r\n * exp(Infinity) = Infinity\r\n * exp(-Infinity) = 0\r\n * exp(NaN) = NaN\r\n * exp(±0) = 1\r\n *\r\n * exp(x) is non-terminating for any finite, non-zero x.\r\n *\r\n * The result will always be correctly rounded.\r\n *\r\n */\r\n function naturalExponential(x, sd) {\r\n var denominator, guard, j, pow, sum, t, wpr,\r\n rep = 0,\r\n i = 0,\r\n k = 0,\r\n Ctor = x.constructor,\r\n rm = Ctor.rounding,\r\n pr = Ctor.precision;\r\n\r\n // 0/NaN/Infinity?\r\n if (!x.d || !x.d[0] || x.e > 17) {\r\n\r\n return new Ctor(x.d\r\n ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0\r\n : x.s ? x.s < 0 ? 0 : x : 0 / 0);\r\n }\r\n\r\n if (sd == null) {\r\n external = false;\r\n wpr = pr;\r\n } else {\r\n wpr = sd;\r\n }\r\n\r\n t = new Ctor(0.03125);\r\n\r\n // while abs(x) >= 0.1\r\n while (x.e > -2) {\r\n\r\n // x = x / 2^5\r\n x = x.times(t);\r\n k += 5;\r\n }\r\n\r\n // Use 2 * log10(2^k) + 5 (empirically derived) to estimate the increase in precision\r\n // necessary to ensure the first 4 rounding digits are correct.\r\n guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n wpr += guard;\r\n denominator = pow = sum = new Ctor(1);\r\n Ctor.precision = wpr;\r\n\r\n for (;;) {\r\n pow = finalise(pow.times(x), wpr, 1);\r\n denominator = denominator.times(++i);\r\n t = sum.plus(divide(pow, denominator, wpr, 1));\r\n\r\n if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n j = k;\r\n while (j--) sum = finalise(sum.times(sum), wpr, 1);\r\n\r\n // Check to see if the first 4 rounding digits are [49]999.\r\n // If so, repeat the summation with a higher precision, otherwise\r\n // e.g. with precision: 18, rounding: 1\r\n // exp(18.404272462595034083567793919843761) = 98372560.1229999999 (should be 98372560.123)\r\n // `wpr - guard` is the index of first rounding digit.\r\n if (sd == null) {\r\n\r\n if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n Ctor.precision = wpr += 10;\r\n denominator = pow = t = new Ctor(1);\r\n i = 0;\r\n rep++;\r\n } else {\r\n return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n }\r\n } else {\r\n Ctor.precision = pr;\r\n return sum;\r\n }\r\n }\r\n\r\n sum = t;\r\n }\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n * ln(-n) = NaN\r\n * ln(0) = -Infinity\r\n * ln(-0) = -Infinity\r\n * ln(1) = 0\r\n * ln(Infinity) = Infinity\r\n * ln(-Infinity) = NaN\r\n * ln(NaN) = NaN\r\n *\r\n * ln(n) (n != 1) is non-terminating.\r\n *\r\n */\r\n function naturalLogarithm(y, sd) {\r\n var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, x2,\r\n n = 1,\r\n guard = 10,\r\n x = y,\r\n xd = x.d,\r\n Ctor = x.constructor,\r\n rm = Ctor.rounding,\r\n pr = Ctor.precision;\r\n\r\n // Is x negative or Infinity, NaN, 0 or 1?\r\n if (x.s < 0 || !xd || !xd[0] || !x.e && xd[0] == 1 && xd.length == 1) {\r\n return new Ctor(xd && !xd[0] ? -1 / 0 : x.s != 1 ? NaN : xd ? 0 : x);\r\n }\r\n\r\n if (sd == null) {\r\n external = false;\r\n wpr = pr;\r\n } else {\r\n wpr = sd;\r\n }\r\n\r\n Ctor.precision = wpr += guard;\r\n c = digitsToString(xd);\r\n c0 = c.charAt(0);\r\n\r\n if (Math.abs(e = x.e) < 1.5e15) {\r\n\r\n // Argument reduction.\r\n // The series converges faster the closer the argument is to 1, so using\r\n // ln(a^b) = b * ln(a), ln(a) = ln(a^b) / b\r\n // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n // later be divided by this number, then separate out the power of 10 using\r\n // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n // max n is 6 (gives 0.7 - 1.3)\r\n while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n x = x.times(y);\r\n c = digitsToString(x.d);\r\n c0 = c.charAt(0);\r\n n++;\r\n }\r\n\r\n e = x.e;\r\n\r\n if (c0 > 1) {\r\n x = new Ctor('0.' + c);\r\n e++;\r\n } else {\r\n x = new Ctor(c0 + '.' + c.slice(1));\r\n }\r\n } else {\r\n\r\n // The argument reduction method above may result in overflow if the argument y is a massive\r\n // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n x = naturalLogarithm(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n Ctor.precision = pr;\r\n\r\n return sd == null ? finalise(x, pr, rm, external = true) : x;\r\n }\r\n\r\n // x1 is x reduced to a value near 1.\r\n x1 = x;\r\n\r\n // Taylor series.\r\n // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n // where x = (y - 1)/(y + 1) (|x| < 1)\r\n sum = numerator = x = divide(x.minus(1), x.plus(1), wpr, 1);\r\n x2 = finalise(x.times(x), wpr, 1);\r\n denominator = 3;\r\n\r\n for (;;) {\r\n numerator = finalise(numerator.times(x2), wpr, 1);\r\n t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));\r\n\r\n if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n sum = sum.times(2);\r\n\r\n // Reverse the argument reduction. Check that e is not 0 because, besides preventing an\r\n // unnecessary calculation, -0 + 0 = +0 and to ensure correct rounding -0 needs to stay -0.\r\n if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n sum = divide(sum, new Ctor(n), wpr, 1);\r\n\r\n // Is rm > 3 and the first 4 rounding digits 4999, or rm < 4 (or the summation has\r\n // been repeated previously) and the first 4 rounding digits 9999?\r\n // If so, restart the summation with a higher precision, otherwise\r\n // e.g. with precision: 12, rounding: 1\r\n // ln(135520028.6126091714265381533) = 18.7246299999 when it should be 18.72463.\r\n // `wpr - guard` is the index of first rounding digit.\r\n if (sd == null) {\r\n if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n Ctor.precision = wpr += guard;\r\n t = numerator = x = divide(x1.minus(1), x1.plus(1), wpr, 1);\r\n x2 = finalise(x.times(x), wpr, 1);\r\n denominator = rep = 1;\r\n } else {\r\n return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n }\r\n } else {\r\n Ctor.precision = pr;\r\n return sum;\r\n }\r\n }\r\n\r\n sum = t;\r\n denominator += 2;\r\n }\r\n }\r\n\r\n\r\n // ±Infinity, NaN.\r\n function nonFiniteToString(x) {\r\n // Unsigned.\r\n return String(x.s * x.s / 0);\r\n }\r\n\r\n\r\n /*\r\n * Parse the value of a new Decimal `x` from string `str`.\r\n */\r\n function parseDecimal(x, str) {\r\n var e, i, len;\r\n\r\n // Decimal point?\r\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n // Exponential form?\r\n if ((i = str.search(/e/i)) > 0) {\r\n\r\n // Determine exponent.\r\n if (e < 0) e = i;\r\n e += +str.slice(i + 1);\r\n str = str.substring(0, i);\r\n } else if (e < 0) {\r\n\r\n // Integer.\r\n e = str.length;\r\n }\r\n\r\n // Determine leading zeros.\r\n for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n // Determine trailing zeros.\r\n for (len = str.length; str.charCodeAt(len - 1) === 48; --len);\r\n str = str.slice(i, len);\r\n\r\n if (str) {\r\n len -= i;\r\n x.e = e = e - i - 1;\r\n x.d = [];\r\n\r\n // Transform base\r\n\r\n // e is the base 10 exponent.\r\n // i is where to slice str to get the first word of the digits array.\r\n i = (e + 1) % LOG_BASE;\r\n if (e < 0) i += LOG_BASE;\r\n\r\n if (i < len) {\r\n if (i) x.d.push(+str.slice(0, i));\r\n for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n str = str.slice(i);\r\n i = LOG_BASE - str.length;\r\n } else {\r\n i -= len;\r\n }\r\n\r\n for (; i--;) str += '0';\r\n x.d.push(+str);\r\n\r\n if (external) {\r\n\r\n // Overflow?\r\n if (x.e > x.constructor.maxE) {\r\n\r\n // Infinity.\r\n x.d = null;\r\n x.e = NaN;\r\n\r\n // Underflow?\r\n } else if (x.e < x.constructor.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n // x.constructor.underflow = true;\r\n } // else x.constructor.underflow = false;\r\n }\r\n } else {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Parse the value of a new Decimal `x` from a string `str`, which is not a decimal value.\r\n */\r\n function parseOther(x, str) {\r\n var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n if (str === 'Infinity' || str === 'NaN') {\r\n if (!+str) x.s = NaN;\r\n x.e = NaN;\r\n x.d = null;\r\n return x;\r\n }\r\n\r\n if (isHex.test(str)) {\r\n base = 16;\r\n str = str.toLowerCase();\r\n } else if (isBinary.test(str)) {\r\n base = 2;\r\n } else if (isOctal.test(str)) {\r\n base = 8;\r\n } else {\r\n throw Error(invalidArgument + str);\r\n }\r\n\r\n // Is there a binary exponent part?\r\n i = str.search(/p/i);\r\n\r\n if (i > 0) {\r\n p = +str.slice(i + 1);\r\n str = str.substring(2, i);\r\n } else {\r\n str = str.slice(2);\r\n }\r\n\r\n // Convert `str` as an integer then divide the result by `base` raised to a power such that the\r\n // fraction part will be restored.\r\n i = str.indexOf('.');\r\n isFloat = i >= 0;\r\n Ctor = x.constructor;\r\n\r\n if (isFloat) {\r\n str = str.replace('.', '');\r\n len = str.length;\r\n i = len - i;\r\n\r\n // log[10](16) = 1.2041... , log[10](88) = 1.9444....\r\n divisor = intPow(Ctor, new Ctor(base), i, i * 2);\r\n }\r\n\r\n xd = convertBase(str, base, BASE);\r\n xe = xd.length - 1;\r\n\r\n // Remove trailing zeros.\r\n for (i = xe; xd[i] === 0; --i) xd.pop();\r\n if (i < 0) return new Ctor(x.s * 0);\r\n x.e = getBase10Exponent(xd, xe);\r\n x.d = xd;\r\n external = false;\r\n\r\n // At what precision to perform the division to ensure exact conversion?\r\n // maxDecimalIntegerPartDigitCount = ceil(log[10](b) * otherBaseIntegerPartDigitCount)\r\n // log[10](2) = 0.30103, log[10](8) = 0.90309, log[10](16) = 1.20412\r\n // E.g. ceil(1.2 * 3) = 4, so up to 4 decimal digits are needed to represent 3 hex int digits.\r\n // maxDecimalFractionPartDigitCount = {Hex:4|Oct:3|Bin:1} * otherBaseFractionPartDigitCount\r\n // Therefore using 4 * the number of digits of str will always be enough.\r\n if (isFloat) x = divide(x, divisor, len * 4);\r\n\r\n // Multiply by the binary exponent part if present.\r\n if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));\r\n external = true;\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\n function sine(Ctor, x) {\r\n var k,\r\n len = x.d.length;\r\n\r\n if (len < 3) return taylorSeries(Ctor, 2, x, x);\r\n\r\n // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)\r\n // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)\r\n // and sin(x) = sin(x/5)(5 + sin^2(x/5)(16sin^2(x/5) - 20))\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n k = 1.4 * Math.sqrt(len);\r\n k = k > 16 ? 16 : k | 0;\r\n\r\n x = x.times(1 / tinyPow(5, k));\r\n x = taylorSeries(Ctor, 2, x, x);\r\n\r\n // Reverse argument reduction\r\n var sin2_x,\r\n d5 = new Ctor(5),\r\n d16 = new Ctor(16),\r\n d20 = new Ctor(20);\r\n for (; k--;) {\r\n sin2_x = x.times(x);\r\n x = x.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n // Calculate Taylor series for `cos`, `cosh`, `sin` and `sinh`.\r\n function taylorSeries(Ctor, n, x, y, isHyperbolic) {\r\n var j, t, u, x2,\r\n i = 1,\r\n pr = Ctor.precision,\r\n k = Math.ceil(pr / LOG_BASE);\r\n\r\n external = false;\r\n x2 = x.times(x);\r\n u = new Ctor(y);\r\n\r\n for (;;) {\r\n t = divide(u.times(x2), new Ctor(n++ * n++), pr, 1);\r\n u = isHyperbolic ? y.plus(t) : y.minus(t);\r\n y = divide(t.times(x2), new Ctor(n++ * n++), pr, 1);\r\n t = u.plus(y);\r\n\r\n if (t.d[k] !== void 0) {\r\n for (j = k; t.d[j] === u.d[j] && j--;);\r\n if (j == -1) break;\r\n }\r\n\r\n j = u;\r\n u = y;\r\n y = t;\r\n t = j;\r\n i++;\r\n }\r\n\r\n external = true;\r\n t.d.length = k + 1;\r\n\r\n return t;\r\n }\r\n\r\n\r\n // Exponent e must be positive and non-zero.\r\n function tinyPow(b, e) {\r\n var n = b;\r\n while (--e) n *= b;\r\n return n;\r\n }\r\n\r\n\r\n // Return the absolute value of `x` reduced to less than or equal to half pi.\r\n function toLessThanHalfPi(Ctor, x) {\r\n var t,\r\n isNeg = x.s < 0,\r\n pi = getPi(Ctor, Ctor.precision, 1),\r\n halfPi = pi.times(0.5);\r\n\r\n x = x.abs();\r\n\r\n if (x.lte(halfPi)) {\r\n quadrant = isNeg ? 4 : 1;\r\n return x;\r\n }\r\n\r\n t = x.divToInt(pi);\r\n\r\n if (t.isZero()) {\r\n quadrant = isNeg ? 3 : 2;\r\n } else {\r\n x = x.minus(t.times(pi));\r\n\r\n // 0 <= x < pi\r\n if (x.lte(halfPi)) {\r\n quadrant = isOdd(t) ? (isNeg ? 2 : 3) : (isNeg ? 4 : 1);\r\n return x;\r\n }\r\n\r\n quadrant = isOdd(t) ? (isNeg ? 1 : 4) : (isNeg ? 3 : 2);\r\n }\r\n\r\n return x.minus(pi).abs();\r\n }\r\n\r\n\r\n /*\r\n * Return the value of Decimal `x` as a string in base `baseOut`.\r\n *\r\n * If the optional `sd` argument is present include a binary exponent suffix.\r\n */\r\n function toStringBinary(x, baseOut, sd, rm) {\r\n var base, e, i, k, len, roundUp, str, xd, y,\r\n Ctor = x.constructor,\r\n isExp = sd !== void 0;\r\n\r\n if (isExp) {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n } else {\r\n sd = Ctor.precision;\r\n rm = Ctor.rounding;\r\n }\r\n\r\n if (!x.isFinite()) {\r\n str = nonFiniteToString(x);\r\n } else {\r\n str = finiteToString(x);\r\n i = str.indexOf('.');\r\n\r\n // Use exponential notation according to `toExpPos` and `toExpNeg`? No, but if required:\r\n // maxBinaryExponent = floor((decimalExponent + 1) * log[2](10))\r\n // minBinaryExponent = floor(decimalExponent * log[2](10))\r\n // log[2](10) = 3.321928094887362347870319429489390175864\r\n\r\n if (isExp) {\r\n base = 2;\r\n if (baseOut == 16) {\r\n sd = sd * 4 - 3;\r\n } else if (baseOut == 8) {\r\n sd = sd * 3 - 2;\r\n }\r\n } else {\r\n base = baseOut;\r\n }\r\n\r\n // Convert the number as an integer then divide the result by its base raised to a power such\r\n // that the fraction part will be restored.\r\n\r\n // Non-integer.\r\n if (i >= 0) {\r\n str = str.replace('.', '');\r\n y = new Ctor(1);\r\n y.e = str.length - i;\r\n y.d = convertBase(finiteToString(y), 10, base);\r\n y.e = y.d.length;\r\n }\r\n\r\n xd = convertBase(str, 10, base);\r\n e = len = xd.length;\r\n\r\n // Remove trailing zeros.\r\n for (; xd[--len] == 0;) xd.pop();\r\n\r\n if (!xd[0]) {\r\n str = isExp ? '0p+0' : '0';\r\n } else {\r\n if (i < 0) {\r\n e--;\r\n } else {\r\n x = new Ctor(x);\r\n x.d = xd;\r\n x.e = e;\r\n x = divide(x, y, sd, rm, 0, base);\r\n xd = x.d;\r\n e = x.e;\r\n roundUp = inexact;\r\n }\r\n\r\n // The rounding digit, i.e. the digit after the digit that may be rounded up.\r\n i = xd[sd];\r\n k = base / 2;\r\n roundUp = roundUp || xd[sd + 1] !== void 0;\r\n\r\n roundUp = rm < 4\r\n ? (i !== void 0 || roundUp) && (rm === 0 || rm === (x.s < 0 ? 3 : 2))\r\n : i > k || i === k && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 ||\r\n rm === (x.s < 0 ? 8 : 7));\r\n\r\n xd.length = sd;\r\n\r\n if (roundUp) {\r\n\r\n // Rounding up may mean the previous digit has to be rounded up and so on.\r\n for (; ++xd[--sd] > base - 1;) {\r\n xd[sd] = 0;\r\n if (!sd) {\r\n ++e;\r\n xd.unshift(1);\r\n }\r\n }\r\n }\r\n\r\n // Determine trailing zeros.\r\n for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n // E.g. [4, 11, 15] becomes 4bf.\r\n for (i = 0, str = ''; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n\r\n // Add binary exponent suffix?\r\n if (isExp) {\r\n if (len > 1) {\r\n if (baseOut == 16 || baseOut == 8) {\r\n i = baseOut == 16 ? 4 : 3;\r\n for (--len; len % i; len++) str += '0';\r\n xd = convertBase(str, base, baseOut);\r\n for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n // xd[0] will always be be 1\r\n for (i = 1, str = '1.'; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n } else {\r\n str = str.charAt(0) + '.' + str.slice(1);\r\n }\r\n }\r\n\r\n str = str + (e < 0 ? 'p' : 'p+') + e;\r\n } else if (e < 0) {\r\n for (; ++e;) str = '0' + str;\r\n str = '0.' + str;\r\n } else {\r\n if (++e > len) for (e -= len; e-- ;) str += '0';\r\n else if (e < len) str = str.slice(0, e) + '.' + str.slice(e);\r\n }\r\n }\r\n\r\n str = (baseOut == 16 ? '0x' : baseOut == 2 ? '0b' : baseOut == 8 ? '0o' : '') + str;\r\n }\r\n\r\n return x.s < 0 ? '-' + str : str;\r\n }\r\n\r\n\r\n // Does not strip trailing zeros.\r\n function truncate(arr, len) {\r\n if (arr.length > len) {\r\n arr.length = len;\r\n return true;\r\n }\r\n }\r\n\r\n\r\n // Decimal methods\r\n\r\n\r\n /*\r\n * abs\r\n * acos\r\n * acosh\r\n * add\r\n * asin\r\n * asinh\r\n * atan\r\n * atanh\r\n * atan2\r\n * cbrt\r\n * ceil\r\n * clone\r\n * config\r\n * cos\r\n * cosh\r\n * div\r\n * exp\r\n * floor\r\n * hypot\r\n * ln\r\n * log\r\n * log2\r\n * log10\r\n * max\r\n * min\r\n * mod\r\n * mul\r\n * pow\r\n * random\r\n * round\r\n * set\r\n * sign\r\n * sin\r\n * sinh\r\n * sqrt\r\n * sub\r\n * tan\r\n * tanh\r\n * trunc\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the absolute value of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function abs(x) {\r\n return new this(x).abs();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arccosine in radians of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function acos(x) {\r\n return new this(x).acos();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function acosh(x) {\r\n return new this(x).acosh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sum of `x` and `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function add(x, y) {\r\n return new this(x).plus(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arcsine in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function asin(x) {\r\n return new this(x).asin();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function asinh(x) {\r\n return new this(x).asinh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function atan(x) {\r\n return new this(x).atan();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function atanh(x) {\r\n return new this(x).atanh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent in radians of `y/x` in the range -pi to pi\r\n * (inclusive), rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi, pi]\r\n *\r\n * y {number|string|Decimal} The y-coordinate.\r\n * x {number|string|Decimal} The x-coordinate.\r\n *\r\n * atan2(±0, -0) = ±pi\r\n * atan2(±0, +0) = ±0\r\n * atan2(±0, -x) = ±pi for x > 0\r\n * atan2(±0, x) = ±0 for x > 0\r\n * atan2(-y, ±0) = -pi/2 for y > 0\r\n * atan2(y, ±0) = pi/2 for y > 0\r\n * atan2(±y, -Infinity) = ±pi for finite y > 0\r\n * atan2(±y, +Infinity) = ±0 for finite y > 0\r\n * atan2(±Infinity, x) = ±pi/2 for finite x\r\n * atan2(±Infinity, -Infinity) = ±3*pi/4\r\n * atan2(±Infinity, +Infinity) = ±pi/4\r\n * atan2(NaN, x) = NaN\r\n * atan2(y, NaN) = NaN\r\n *\r\n */\r\n function atan2(y, x) {\r\n y = new this(y);\r\n x = new this(x);\r\n var r,\r\n pr = this.precision,\r\n rm = this.rounding,\r\n wpr = pr + 4;\r\n\r\n // Either NaN\r\n if (!y.s || !x.s) {\r\n r = new this(NaN);\r\n\r\n // Both ±Infinity\r\n } else if (!y.d && !x.d) {\r\n r = getPi(this, wpr, 1).times(x.s > 0 ? 0.25 : 0.75);\r\n r.s = y.s;\r\n\r\n // x is ±Infinity or y is ±0\r\n } else if (!x.d || y.isZero()) {\r\n r = x.s < 0 ? getPi(this, pr, rm) : new this(0);\r\n r.s = y.s;\r\n\r\n // y is ±Infinity or x is ±0\r\n } else if (!y.d || x.isZero()) {\r\n r = getPi(this, wpr, 1).times(0.5);\r\n r.s = y.s;\r\n\r\n // Both non-zero and finite\r\n } else if (x.s < 0) {\r\n this.precision = wpr;\r\n this.rounding = 1;\r\n r = this.atan(divide(y, x, wpr, 1));\r\n x = getPi(this, wpr, 1);\r\n this.precision = pr;\r\n this.rounding = rm;\r\n r = y.s < 0 ? r.minus(x) : r.plus(x);\r\n } else {\r\n r = this.atan(divide(y, x, wpr, 1));\r\n }\r\n\r\n return r;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cube root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function cbrt(x) {\r\n return new this(x).cbrt();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` rounded to an integer using `ROUND_CEIL`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function ceil(x) {\r\n return finalise(x = new this(x), x.e + 1, 2);\r\n }\r\n\r\n\r\n /*\r\n * Configure global settings for a Decimal constructor.\r\n *\r\n * `obj` is an object with one or more of the following properties,\r\n *\r\n * precision {number}\r\n * rounding {number}\r\n * toExpNeg {number}\r\n * toExpPos {number}\r\n * maxE {number}\r\n * minE {number}\r\n * modulo {number}\r\n * crypto {boolean|number}\r\n * defaults {true}\r\n *\r\n * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n *\r\n */\r\n function config(obj) {\r\n if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');\r\n var i, p, v,\r\n useDefaults = obj.defaults === true,\r\n ps = [\r\n 'precision', 1, MAX_DIGITS,\r\n 'rounding', 0, 8,\r\n 'toExpNeg', -EXP_LIMIT, 0,\r\n 'toExpPos', 0, EXP_LIMIT,\r\n 'maxE', 0, EXP_LIMIT,\r\n 'minE', -EXP_LIMIT, 0,\r\n 'modulo', 0, 9\r\n ];\r\n\r\n for (i = 0; i < ps.length; i += 3) {\r\n if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];\r\n if ((v = obj[p]) !== void 0) {\r\n if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n else throw Error(invalidArgument + p + ': ' + v);\r\n }\r\n }\r\n\r\n if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];\r\n if ((v = obj[p]) !== void 0) {\r\n if (v === true || v === false || v === 0 || v === 1) {\r\n if (v) {\r\n if (typeof crypto != 'undefined' && crypto &&\r\n (crypto.getRandomValues || crypto.randomBytes)) {\r\n this[p] = true;\r\n } else {\r\n throw Error(cryptoUnavailable);\r\n }\r\n } else {\r\n this[p] = false;\r\n }\r\n } else {\r\n throw Error(invalidArgument + p + ': ' + v);\r\n }\r\n }\r\n\r\n return this;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cosine of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function cos(x) {\r\n return new this(x).cos();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic cosine of `x`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function cosh(x) {\r\n return new this(x).cosh();\r\n }\r\n\r\n\r\n /*\r\n * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n * constructor.\r\n *\r\n */\r\n function clone(obj) {\r\n var i, p, ps;\r\n\r\n /*\r\n * The Decimal constructor and exported function.\r\n * Return a new Decimal instance.\r\n *\r\n * v {number|string|Decimal} A numeric value.\r\n *\r\n */\r\n function Decimal(v) {\r\n var e, i, t,\r\n x = this;\r\n\r\n // Decimal called without new.\r\n if (!(x instanceof Decimal)) return new Decimal(v);\r\n\r\n // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n // which points to Object.\r\n x.constructor = Decimal;\r\n\r\n // Duplicate.\r\n if (v instanceof Decimal) {\r\n x.s = v.s;\r\n\r\n if (external) {\r\n if (!v.d || v.e > Decimal.maxE) {\r\n\r\n // Infinity.\r\n x.e = NaN;\r\n x.d = null;\r\n } else if (v.e < Decimal.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n } else {\r\n x.e = v.e;\r\n x.d = v.d.slice();\r\n }\r\n } else {\r\n x.e = v.e;\r\n x.d = v.d ? v.d.slice() : v.d;\r\n }\r\n\r\n return;\r\n }\r\n\r\n t = typeof v;\r\n\r\n if (t === 'number') {\r\n if (v === 0) {\r\n x.s = 1 / v < 0 ? -1 : 1;\r\n x.e = 0;\r\n x.d = [0];\r\n return;\r\n }\r\n\r\n if (v < 0) {\r\n v = -v;\r\n x.s = -1;\r\n } else {\r\n x.s = 1;\r\n }\r\n\r\n // Fast path for small integers.\r\n if (v === ~~v && v < 1e7) {\r\n for (e = 0, i = v; i >= 10; i /= 10) e++;\r\n\r\n if (external) {\r\n if (e > Decimal.maxE) {\r\n x.e = NaN;\r\n x.d = null;\r\n } else if (e < Decimal.minE) {\r\n x.e = 0;\r\n x.d = [0];\r\n } else {\r\n x.e = e;\r\n x.d = [v];\r\n }\r\n } else {\r\n x.e = e;\r\n x.d = [v];\r\n }\r\n\r\n return;\r\n\r\n // Infinity, NaN.\r\n } else if (v * 0 !== 0) {\r\n if (!v) x.s = NaN;\r\n x.e = NaN;\r\n x.d = null;\r\n return;\r\n }\r\n\r\n return parseDecimal(x, v.toString());\r\n\r\n } else if (t !== 'string') {\r\n throw Error(invalidArgument + v);\r\n }\r\n\r\n // Minus sign?\r\n if ((i = v.charCodeAt(0)) === 45) {\r\n v = v.slice(1);\r\n x.s = -1;\r\n } else {\r\n // Plus sign?\r\n if (i === 43) v = v.slice(1);\r\n x.s = 1;\r\n }\r\n\r\n return isDecimal.test(v) ? parseDecimal(x, v) : parseOther(x, v);\r\n }\r\n\r\n Decimal.prototype = P;\r\n\r\n Decimal.ROUND_UP = 0;\r\n Decimal.ROUND_DOWN = 1;\r\n Decimal.ROUND_CEIL = 2;\r\n Decimal.ROUND_FLOOR = 3;\r\n Decimal.ROUND_HALF_UP = 4;\r\n Decimal.ROUND_HALF_DOWN = 5;\r\n Decimal.ROUND_HALF_EVEN = 6;\r\n Decimal.ROUND_HALF_CEIL = 7;\r\n Decimal.ROUND_HALF_FLOOR = 8;\r\n Decimal.EUCLID = 9;\r\n\r\n Decimal.config = Decimal.set = config;\r\n Decimal.clone = clone;\r\n Decimal.isDecimal = isDecimalInstance;\r\n\r\n Decimal.abs = abs;\r\n Decimal.acos = acos;\r\n Decimal.acosh = acosh; // ES6\r\n Decimal.add = add;\r\n Decimal.asin = asin;\r\n Decimal.asinh = asinh; // ES6\r\n Decimal.atan = atan;\r\n Decimal.atanh = atanh; // ES6\r\n Decimal.atan2 = atan2;\r\n Decimal.cbrt = cbrt; // ES6\r\n Decimal.ceil = ceil;\r\n Decimal.cos = cos;\r\n Decimal.cosh = cosh; // ES6\r\n Decimal.div = div;\r\n Decimal.exp = exp;\r\n Decimal.floor = floor;\r\n Decimal.hypot = hypot; // ES6\r\n Decimal.ln = ln;\r\n Decimal.log = log;\r\n Decimal.log10 = log10; // ES6\r\n Decimal.log2 = log2; // ES6\r\n Decimal.max = max;\r\n Decimal.min = min;\r\n Decimal.mod = mod;\r\n Decimal.mul = mul;\r\n Decimal.pow = pow;\r\n Decimal.random = random;\r\n Decimal.round = round;\r\n Decimal.sign = sign; // ES6\r\n Decimal.sin = sin;\r\n Decimal.sinh = sinh; // ES6\r\n Decimal.sqrt = sqrt;\r\n Decimal.sub = sub;\r\n Decimal.tan = tan;\r\n Decimal.tanh = tanh; // ES6\r\n Decimal.trunc = trunc; // ES6\r\n\r\n if (obj === void 0) obj = {};\r\n if (obj) {\r\n if (obj.defaults !== true) {\r\n ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];\r\n for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n }\r\n }\r\n\r\n Decimal.config(obj);\r\n\r\n return Decimal;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` divided by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function div(x, y) {\r\n return new this(x).div(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The power to which to raise the base of the natural log.\r\n *\r\n */\r\n function exp(x) {\r\n return new this(x).exp();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` round to an integer using `ROUND_FLOOR`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function floor(x) {\r\n return finalise(x = new this(x), x.e + 1, 3);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of the sum of the squares of the arguments,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function hypot() {\r\n var i, n,\r\n t = new this(0);\r\n\r\n external = false;\r\n\r\n for (i = 0; i < arguments.length;) {\r\n n = new this(arguments[i++]);\r\n if (!n.d) {\r\n if (n.s) {\r\n external = true;\r\n return new this(1 / 0);\r\n }\r\n t = n;\r\n } else if (t.d) {\r\n t = t.plus(n.times(n));\r\n }\r\n }\r\n\r\n external = true;\r\n\r\n return t.sqrt();\r\n }\r\n\r\n\r\n /*\r\n * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),\r\n * otherwise return false.\r\n *\r\n */\r\n function isDecimalInstance(obj) {\r\n return obj instanceof Decimal || obj && obj.name === '[object Decimal]' || false;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function ln(x) {\r\n return new this(x).ln();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the log of `x` to the base `y`, or to base 10 if no base\r\n * is specified, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * log[y](x)\r\n *\r\n * x {number|string|Decimal} The argument of the logarithm.\r\n * y {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\n function log(x, y) {\r\n return new this(x).log(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the base 2 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function log2(x) {\r\n return new this(x).log(2);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the base 10 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function log10(x) {\r\n return new this(x).log(10);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function max() {\r\n return maxOrMin(this, arguments, 'lt');\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function min() {\r\n return maxOrMin(this, arguments, 'gt');\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` modulo `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function mod(x, y) {\r\n return new this(x).mod(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` multiplied by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function mul(x, y) {\r\n return new this(x).mul(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` raised to the power `y`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The base.\r\n * y {number|string|Decimal} The exponent.\r\n *\r\n */\r\n function pow(x, y) {\r\n return new this(x).pow(y);\r\n }\r\n\r\n\r\n /*\r\n * Returns a new Decimal with a random value equal to or greater than 0 and less than 1, and with\r\n * `sd`, or `Decimal.precision` if `sd` is omitted, significant digits (or less if trailing zeros\r\n * are produced).\r\n *\r\n * [sd] {number} Significant digits. Integer, 0 to MAX_DIGITS inclusive.\r\n *\r\n */\r\n function random(sd) {\r\n var d, e, k, n,\r\n i = 0,\r\n r = new this(1),\r\n rd = [];\r\n\r\n if (sd === void 0) sd = this.precision;\r\n else checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n k = Math.ceil(sd / LOG_BASE);\r\n\r\n if (!this.crypto) {\r\n for (; i < k;) rd[i++] = Math.random() * 1e7 | 0;\r\n\r\n // Browsers supporting crypto.getRandomValues.\r\n } else if (crypto.getRandomValues) {\r\n d = crypto.getRandomValues(new Uint32Array(k));\r\n\r\n for (; i < k;) {\r\n n = d[i];\r\n\r\n // 0 <= n < 4294967296\r\n // Probability n >= 4.29e9, is 4967296 / 4294967296 = 0.00116 (1 in 865).\r\n if (n >= 4.29e9) {\r\n d[i] = crypto.getRandomValues(new Uint32Array(1))[0];\r\n } else {\r\n\r\n // 0 <= n <= 4289999999\r\n // 0 <= (n % 1e7) <= 9999999\r\n rd[i++] = n % 1e7;\r\n }\r\n }\r\n\r\n // Node.js supporting crypto.randomBytes.\r\n } else if (crypto.randomBytes) {\r\n\r\n // buffer\r\n d = crypto.randomBytes(k *= 4);\r\n\r\n for (; i < k;) {\r\n\r\n // 0 <= n < 2147483648\r\n n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 0x7f) << 24);\r\n\r\n // Probability n >= 2.14e9, is 7483648 / 2147483648 = 0.0035 (1 in 286).\r\n if (n >= 2.14e9) {\r\n crypto.randomBytes(4).copy(d, i);\r\n } else {\r\n\r\n // 0 <= n <= 2139999999\r\n // 0 <= (n % 1e7) <= 9999999\r\n rd.push(n % 1e7);\r\n i += 4;\r\n }\r\n }\r\n\r\n i = k / 4;\r\n } else {\r\n throw Error(cryptoUnavailable);\r\n }\r\n\r\n k = rd[--i];\r\n sd %= LOG_BASE;\r\n\r\n // Convert trailing digits to zeros according to sd.\r\n if (k && sd) {\r\n n = mathpow(10, LOG_BASE - sd);\r\n rd[i] = (k / n | 0) * n;\r\n }\r\n\r\n // Remove trailing words which are zero.\r\n for (; rd[i] === 0; i--) rd.pop();\r\n\r\n // Zero?\r\n if (i < 0) {\r\n e = 0;\r\n rd = [0];\r\n } else {\r\n e = -1;\r\n\r\n // Remove leading words which are zero and adjust exponent accordingly.\r\n for (; rd[0] === 0; e -= LOG_BASE) rd.shift();\r\n\r\n // Count the digits of the first word of rd to determine leading zeros.\r\n for (k = 1, n = rd[0]; n >= 10; n /= 10) k++;\r\n\r\n // Adjust the exponent for leading zeros of the first word of rd.\r\n if (k < LOG_BASE) e -= LOG_BASE - k;\r\n }\r\n\r\n r.e = e;\r\n r.d = rd;\r\n\r\n return r;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` rounded to an integer using rounding mode `rounding`.\r\n *\r\n * To emulate `Math.round`, set rounding to 7 (ROUND_HALF_CEIL).\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function round(x) {\r\n return finalise(x = new this(x), x.e + 1, this.rounding);\r\n }\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if x > 0,\r\n * -1 if x < 0,\r\n * 0 if x is 0,\r\n * -0 if x is -0,\r\n * NaN otherwise\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function sign(x) {\r\n x = new this(x);\r\n return x.d ? (x.d[0] ? x.s : 0 * x.s) : x.s || NaN;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sine of `x`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function sin(x) {\r\n return new this(x).sin();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic sine of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function sinh(x) {\r\n return new this(x).sinh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function sqrt(x) {\r\n return new this(x).sqrt();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` minus `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function sub(x, y) {\r\n return new this(x).sub(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function tan(x) {\r\n return new this(x).tan();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic tangent of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function tanh(x) {\r\n return new this(x).tanh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` truncated to an integer.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function trunc(x) {\r\n return finalise(x = new this(x), x.e + 1, 1);\r\n }\r\n\r\n\r\n // Create and configure initial Decimal constructor.\r\n Decimal = clone(DEFAULTS);\r\n\r\n Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n // Create the internal constants from their string values.\r\n LN10 = new Decimal(LN10);\r\n PI = new Decimal(PI);\r\n\r\n\r\n // Export.\r\n\r\n\r\n // AMD.\r\n if (typeof define == 'function' && define.amd) {\r\n define(function () {\r\n return Decimal;\r\n });\r\n\r\n // Node and other environments that support module.exports.\r\n } else if (typeof module != 'undefined' && module.exports) {\r\n if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n P[Symbol.for('nodejs.util.inspect.custom')] = P.toString;\r\n P[Symbol.toStringTag] = 'Decimal';\r\n }\r\n\r\n module.exports = Decimal;\r\n\r\n // Browser.\r\n } else {\r\n if (!globalScope) {\r\n globalScope = typeof self != 'undefined' && self && self.self == self ? self : window;\r\n }\r\n\r\n noConflict = globalScope.Decimal;\r\n Decimal.noConflict = function () {\r\n globalScope.Decimal = noConflict;\r\n return Decimal;\r\n };\r\n\r\n globalScope.Decimal = Decimal;\r\n }\r\n})(this);\r\n"],"sourceRoot":""}