{"version":3,"sources":["webpack:///./node_modules/decimal.js/decimal.js","webpack:///./node_modules/dcxy-device-manage-static/src/api/shower/base.js","webpack:///./node_modules/dcxy-device-manage-static/src/api/shower/oper.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","tag","mathfloor","Math","floor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LOG_BASE","MAX_SAFE_INTEGER","LN10_PRECISION","length","PI_PRECISION","P","toStringTag","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","len","y","isZero","tinyPow","toString","taylorSeries","times","cos2x","minus","plus","absoluteValue","abs","this","constructor","s","finalise","e","clampedTo","clamp","NaN","gt","cmp","comparedTo","xdL","ydL","xd","yd","xs","ys","cos","pr","sd","toLessThanHalfPi","neg","cubeRoot","cbrt","m","n","rep","t","t3","t3plusx","isFinite","toExponential","slice","divide","eq","decimalPlaces","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","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","isDecimalInstance","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","hypot","log10","log2","random","hasOwnProperty","arguments","Uint32Array","copy","manageShell","default","createBaseFetch","baseURL","process","timeout","getOper","entity","url","params"],"mappings":"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","file":"js/chunk-6d78175b.8413f8c7.js","sourcesContent":[";(function (globalScope) {\r\n 'use strict';\r\n\r\n\r\n /*\r\n * decimal.js v10.3.1\r\n * An arbitrary-precision Decimal type for JavaScript.\r\n * https://github.com/MikeMcl/decimal.js\r\n * Copyright (c) 2021 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 tag = '[object Decimal]',\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 = { toStringTag: tag };\r\n\r\n\r\n // Decimal prototype methods\r\n\r\n\r\n /*\r\n * absoluteValue abs\r\n * ceil\r\n * clampedTo clamp\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 a new Decimal whose value is the value of this Decimal clamped to the range\r\n * delineated by `min` and `max`.\r\n *\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\n P.clampedTo = P.clamp = function (min, max) {\r\n var k,\r\n x = this,\r\n Ctor = x.constructor;\r\n min = new Ctor(min);\r\n max = new Ctor(max);\r\n if (!min.s || !max.s) return new Ctor(NaN);\r\n if (min.gt(max)) throw Error(invalidArgument + max);\r\n k = x.cmp(min);\r\n return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);\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 // 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, len, y;\r\n\r\n if (x.isZero()) return x;\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 len = x.d.length;\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.indexOf('_') > -1) {\r\n str = str.replace(/(\\d)_(?=\\d)/g, '$1');\r\n if (isDecimal.test(str)) return parseDecimal(x, str);\r\n } else 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) {\r\n return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);\r\n }\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 * clamp\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 * sum\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 * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.\r\n *\r\n * x {number|string|Decimal}\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\n function clamp(x, min, max) {\r\n return new this(x).clamp(min, max);\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 (isDecimalInstance(v)) {\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.clamp = clamp;\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.sum = sum;\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.toStringTag === tag || 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 sum of the arguments, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * Only the result is rounded, not the intermediate calculations.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function sum() {\r\n var i = 0,\r\n args = arguments,\r\n x = new this(args[i]);\r\n\r\n external = false;\r\n for (; x.s && ++i < args.length;) x = x.plus(args[i]);\r\n external = true;\r\n\r\n return finalise(x, this.precision, this.rounding);\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 Decimal.prototype.constructor = Decimal;\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","const base = manageShell.default.createBaseFetch({\n baseURL:\n process.env.VUE_APP_BASE_SERVER_URL,\n timeout: 10000,\n });\n export default base;","import base from './base';\nexport const getOper = entity =>\nbase({\n url: '/dcxy/baseArea/findServiceOper',\n params:entity,\n \n });\n"],"sourceRoot":""}