https://static.f2pool.com/static/js/decimal.js?v=5ecc27b4f611cfcba…fd34e62a5237cac06d76e7098153c4835192ff9feb4

70      // EUCLID     9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.
71      //
72      // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian
73      // division (9) are commonly used for the modulus operation. The other rounding modes can also
74      // be used, but they may not give useful results.
75      modulo: 1,                             // 0 to 9
76
77      // The exponent value at and beneath which `toString` returns exponential notation.
78      // JavaScript numbers: -7
79      toExpNeg: -7,                          // 0 to -EXP_LIMIT
80
81      // The exponent value at and above which `toString` returns exponential notation.
82      // JavaScript numbers: 21
83      toExpPos:  21,                         // 0 to EXP_LIMIT
84
85      // The minimum exponent value, beneath which underflow to zero occurs.
86      // JavaScript numbers: -324  (5e-324)
87      minE: -EXP_LIMIT,                      // -1 to -EXP_LIMIT
88
89      // The maximum exponent value, above which overflow to Infinity occurs.
90      // JavaScript numbers: 308  (1.7976931348623157e+308)
91      maxE: EXP_LIMIT,                       // 1 to EXP_LIMIT
92
93      // Whether to use cryptographically-secure random number generation, if available.
94      crypto: false                          // true/false
95    },
96
97
98  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //
99
100
101    Decimal, inexact, noConflict, quadrant,
102    external = true,
103
104    decimalError = '[DecimalError] ',
105    invalidArgument = decimalError + 'Invalid argument: ',
106    precisionLimitExceeded = decimalError + 'Precision limit exceeded',
107    cryptoUnavailable = decimalError + 'crypto unavailable',
108    tag = '[object Decimal]',
109
110    mathfloor = Math.floor,
111    mathpow = Math.pow,
112
113    isBinary = /^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,
114    isHex = /^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,
115    isOctal = /^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,
116    isDecimal = /^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,
117
118    BASE = 1e7,
119    LOG_BASE = 7,
120    MAX_SAFE_INTEGER = 9007199254740991,
121
122    LN10_PRECISION = LN10.length - 1,
123    PI_PRECISION = PI.length - 1,
124
125    // Decimal.prototype object
126    P = { toStringTag: tag };
127
128
129  // Decimal prototype methods
130
131
132  /*
133   *  absoluteValue             abs
134   *  ceil
135   *  clampedTo                 clamp
136   *  comparedTo                cmp
137   *  cosine                    cos
138   *  cubeRoot                  cbrt
139   *  decimalPlaces             dp
140   *  dividedBy                 div
141   *  dividedToIntegerBy        divToInt
142   *  equals                    eq
143   *  floor
144   *  greaterThan               gt
145   *  greaterThanOrEqualTo      gte
146   *  hyperbolicCosine          cosh
147   *  hyperbolicSine            sinh
148   *  hyperbolicTangent         tanh
149   *  inverseCosine             acos
150   *  inverseHyperbolicCosine   acosh
151   *  inverseHyperbolicSine     asinh
152   *  inverseHyperbolicTangent  atanh
153   *  inverseSine               asin
154   *  inverseTangent            atan
155   *  isFinite
156   *  isInteger                 isInt
157   *  isNaN
158   *  isNegative                isNeg
159   *  isPositive                isPos
160   *  isZero
161   *  lessThan                  lt
162   *  lessThanOrEqualTo         lte
163   *  logarithm                 log
164   *  [maximum]                 [max]
165   *  [minimum]                 [min]
166   *  minus                     sub
167   *  modulo                    mod
168   *  naturalExponential        exp
169   *  naturalLogarithm          ln
170   *  negated                   neg
171   *  plus                      add
172   *  precision                 sd
173   *  round
174   *  sine                      sin
175   *  squareRoot                sqrt
176   *  tangent                   tan
177   *  times                     mul
178   *  toBinary
179   *  toDecimalPlaces           toDP
180   *  toExponential
181   *  toFixed
182   *  toFraction
183   *  toHexadecimal             toHex
184   *  toNearest
185   *  toNumber
186   *  toOctal
187   *  toPower                   pow
188   *  toPrecision
189   *  toSignificantDigits       toSD
190   *  toString
191   *  truncated                 trunc
192   *  valueOf                   toJSON
193   */
194
195
196  /*
197   * Return a new Decimal whose value is the absolute value of this Decimal.
198   *
199   */
200  P.absoluteValue = P.abs = function () {
201    var x = new this.constructor(this);
202    if (x.s < 0) x.s = 1;
203    return finalise(x);
204  };
205
206
207  /*
208   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the
209   * direction of positive Infinity.
210   *
211   */
212  P.ceil = function () {
213    return finalise(new this.constructor(this), this.e + 1, 2);
214  };
215
216
217  /*
218   * Return a new Decimal whose value is the value of this Decimal clamped to the range
219   * delineated by `min` and `max`.
220   *
221   * min {number|string|Decimal}
222   * max {number|string|Decimal}
223   *
224   */
225  P.clampedTo = P.clamp = function (min, max) {
226    var k,
227      x = this,
228      Ctor = x.constructor;
229    min = new Ctor(min);
230    max = new Ctor(max);
231    if (!min.s || !max.s) return new Ctor(NaN);
232    if (min.gt(max)) throw Error(invalidArgument + max);
233    k = x.cmp(min);
234    return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);
235  };
236
237
238  /*
239   * Return
240   *   1    if the value of this Decimal is greater than the value of `y`,
241   *  -1    if the value of this Decimal is less than the value of `y`,
242   *   0    if they have the same value,
243   *   NaN  if the value of either Decimal is NaN.
244   *
245   */
246  P.comparedTo = P.cmp = function (y) {
247    var i, j, xdL, ydL,
248      x = this,
249      xd = x.d,
250      yd = (y = new x.constructor(y)).d,
251      xs = x.s,
252      ys = y.s;
253
254    // Either NaN or ±Infinity?
255    if (!xd || !yd) {
256      return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;
257    }
258
259    // Either zero?
260    if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;
261
262    // Signs differ?
263    if (xs !== ys) return xs;
264
265    // Compare exponents.
266    if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;
267
268    xdL = xd.length;
269    ydL = yd.length;
270
271    // Compare digit by digit.
272    for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {
273      if (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;
274    }
275
276    // Compare lengths.
277    return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;
278  };
279
280
281  /*
282   * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.
283   *
284   * Domain: [-Infinity, Infinity]
285   * Range: [-1, 1]
286   *
287   * cos(0)         = 1
288   * cos(-0)        = 1
289   * cos(Infinity)  = NaN
290   * cos(-Infinity) = NaN
291   * cos(NaN)       = NaN
292   *
293   */
294  P.cosine = P.cos = function () {
295    var pr, rm,
296      x = this,
297      Ctor = x.constructor;
298
299    if (!x.d) return new Ctor(NaN);
300
301    // cos(0) = cos(-0) = 1
302    if (!x.d[0]) return new Ctor(1);
303
304    pr = Ctor.precision;
305    rm = Ctor.rounding;
306    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;
307    Ctor.rounding = 1;
308
309    x = cosine(Ctor, toLessThanHalfPi(Ctor, x));
310
311    Ctor.precision = pr;
312    Ctor.rounding = rm;
313
314    return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);
315  };
316
317
318  /*
319   *
320   * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to
321   * `precision` significant digits using rounding mode `rounding`.
322   *
323   *  cbrt(0)  =  0
324   *  cbrt(-0) = -0
325   *  cbrt(1)  =  1
326   *  cbrt(-1) = -1
327   *  cbrt(N)  =  N
328   *  cbrt(-I) = -I
329   *  cbrt(I)  =  I
330   *
331   * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))
332   *
333   */
334  P.cubeRoot = P.cbrt = function () {
335    var e, m, n, r, rep, s, sd, t, t3, t3plusx,
336      x = this,
337      Ctor = x.constructor;
338
339    if (!x.isFinite() || x.isZero()) return new Ctor(x);
340    external = false;
341
342    // Initial estimate.
343    s = x.s * mathpow(x.s * x, 1 / 3);
344
345     // Math.cbrt underflow/overflow?
346     // Pass x to Math.pow as integer, then adjust the exponent of the result.
347    if (!s || Math.abs(s) == 1 / 0) {
348      n = digitsToString(x.d);
349      e = x.e;
350
351      // Adjust n exponent so it is a multiple of 3 away from x exponent.
352      if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');
353      s = mathpow(n, 1 / 3);
354
355      // Rarely, e may be one less than the result exponent value.
356      e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));
357
358      if (s == 1 / 0) {
359        n = '5e' + e;
360      } else {
361        n = s.toExponential();
362        n = n.slice(0, n.indexOf('e') + 1) + e;
363      }
364
365      r = new Ctor(n);
366      r.s = x.s;
367    } else {
368      r = new Ctor(s.toString());
369    }
370
371    sd = (e = Ctor.precision) + 3;
372
373    // Halley's method.
374    // TODO? Compare Newton's method.
375    for (;;) {
376      t = r;
377      t3 = t.times(t).times(t);
378      t3plusx = t3.plus(x);
379      r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);
380
381      // TODO? Replace with for-loop and checkRoundingDigits.
382      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {
383        n = n.slice(sd - 3, sd + 1);
384
385        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999
386        // , i.e. approaching a rounding boundary, continue the iteration.
387        if (n == '9999' || !rep && n == '4999') {
388
389          // On the first iteration only, check to see if rounding up gives the exact result as the
390          // nines may infinitely repeat.
391          if (!rep) {
392            finalise(t, e + 1, 0);
393
394            if (t.times(t).times(t).eq(x)) {
395              r = t;
396              break;
397            }
398          }
399
400          sd += 4;
401          rep = 1;
402        } else {
403
404          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.
405          // If not, then there are further digits and m will be truthy.
406          if (!+n || !+n.slice(1) && n.charAt(0) == '5') {
407
408            // Truncate to the first rounding digit.
409            finalise(r, e + 1, 1);
410            m = !r.times(r).times(r).eq(x);
411          }
412
413          break;
414        }
415      }
416    }
417
418    external = true;
419
420    return finalise(r, e, Ctor.rounding, m);
421  };
422
423
424  /*
425   * Return the number of decimal places of the value of this Decimal.
426   *
427   */
428  P.decimalPlaces = P.dp = function () {
429    var w,
430      d = this.d,
431      n = NaN;
432
433    if (d) {
434      w = d.length - 1;
435      n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;
436
437      // Subtract the number of trailing zeros of the last word.
438      w = d[w];
439      if (w) for (; w % 10 == 0; w /= 10) n--;
440      if (n < 0) n = 0;
441    }
442
443    return n;
444  };
445
446
447  /*
448   *  n / 0 = I
449   *  n / N = N
450   *  n / I = 0
451   *  0 / n = 0
452   *  0 / 0 = N
453   *  0 / N = N
454   *  0 / I = 0
455   *  N / n = N
456   *  N / 0 = N
457   *  N / N = N
458   *  N / I = N
459   *  I / n = I
460   *  I / 0 = I
461   *  I / N = N
462   *  I / I = N
463   *
464   * Return a new Decimal whose value is the value of this Decimal divided by `y`, rounded to
465   * `precision` significant digits using rounding mode `rounding`.
466   *
467   */
468  P.dividedBy = P.div = function (y) {
469    return divide(this, new this.constructor(y));
470  };
471
472
473  /*
474   * Return a new Decimal whose value is the integer part of dividing the value of this Decimal
475   * by the value of `y`, rounded to `precision` significant digits using rounding mode `rounding`.
476   *
477   */
478  P.dividedToIntegerBy = P.divToInt = function (y) {
479    var x = this,
480      Ctor = x.constructor;
481    return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);
482  };
483
484
485  /*
486   * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.
487   *
488   */
489  P.equals = P.eq = function (y) {
490    return this.cmp(y) === 0;
491  };
492
493
494  /*
495   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the
496   * direction of negative Infinity.
497   *
498   */
499  P.floor = function () {
500    return finalise(new this.constructor(this), this.e + 1, 3);
501  };
502
503
504  /*
505   * Return true if the value of this Decimal is greater than the value of `y`, otherwise return
506   * false.
507   *
508   */
509  P.greaterThan = P.gt = function (y) {
510    return this.cmp(y) > 0;
511  };
512
513
514  /*
515   * Return true if the value of this Decimal is greater than or equal to the value of `y`,
516   * otherwise return false.
517   *
518   */
519  P.greaterThanOrEqualTo = P.gte = function (y) {
520    var k = this.cmp(y);
521    return k == 1 || k === 0;
522  };
523
524
525  /*
526   * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this
527   * Decimal.
528   *
529   * Domain: [-Infinity, Infinity]
530   * Range: [1, Infinity]
531   *
532   * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...
533   *
534   * cosh(0)         = 1
535   * cosh(-0)        = 1
536   * cosh(Infinity)  = Infinity
537   * cosh(-Infinity) = Infinity
538   * cosh(NaN)       = NaN
539   *
540   *  x        time taken (ms)   result
541   * 1000      9                 9.8503555700852349694e+433
542   * 10000     25                4.4034091128314607936e+4342
543   * 100000    171               1.4033316802130615897e+43429
544   * 1000000   3817              1.5166076984010437725e+434294
545   * 10000000  abandoned after 2 minute wait
546   *
547   * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))
548   *
549   */
550  P.hyperbolicCosine = P.cosh = function () {
551    var k, n, pr, rm, len,
552      x = this,
553      Ctor = x.constructor,
554      one = new Ctor(1);
555
556    if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);
557    if (x.isZero()) return one;
558
559    pr = Ctor.precision;
560    rm = Ctor.rounding;
561    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;
562    Ctor.rounding = 1;
563    len = x.d.length;
564
565    // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1
566    // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))
567
568    // Estimate the optimum number of times to use the argument reduction.
569    // TODO? Estimation reused from cosine() and may not be optimal here.
570    if (len < 32) {
571      k = Math.ceil(len / 3);
572      n = (1 / tinyPow(4, k)).toString();
573    } else {
574      k = 16;
575      n = '2.3283064365386962890625e-10';
576    }
577
578    x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);
579
580    // Reverse argument reduction
581    var cosh2_x,
582      i = k,
583      d8 = new Ctor(8);
584    for (; i--;) {
585      cosh2_x = x.times(x);
586      x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));
587    }
588
589    return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);
590  };
591
592
593  /*
594   * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this
595   * Decimal.
596   *
597   * Domain: [-Infinity, Infinity]
598   * Range: [-Infinity, Infinity]
599   *
600   * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...
601   *
602   * sinh(0)         = 0
603   * sinh(-0)        = -0
604   * sinh(Infinity)  = Infinity
605   * sinh(-Infinity) = -Infinity
606   * sinh(NaN)       = NaN
607   *
608   * x        time taken (ms)
609   * 10       2 ms
610   * 100      5 ms
611   * 1000     14 ms
612   * 10000    82 ms
613   * 100000   886 ms            1.4033316802130615897e+43429
614   * 200000   2613 ms
615   * 300000   5407 ms
616   * 400000   8824 ms
617   * 500000   13026 ms          8.7080643612718084129e+217146
618   * 1000000  48543 ms
619   *
620   * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))
621   *
622   */
623  P.hyperbolicSine = P.sinh = function () {
624    var k, pr, rm, len,
625      x = this,
626      Ctor = x.constructor;
627
628    if (!x.isFinite() || x.isZero()) return new Ctor(x);
629
630    pr = Ctor.precision;
631    rm = Ctor.rounding;
632    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;
633    Ctor.rounding = 1;
634    len = x.d.length;
635
636    if (len < 3) {
637      x = taylorSeries(Ctor, 2, x, x, true);
638    } else {
639
640      // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))
641      // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))
642      // 3 multiplications and 1 addition
643
644      // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))
645      // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))
646      // 4 multiplications and 2 additions
647
648      // Estimate the optimum number of times to use the argument reduction.
649      k = 1.4 * Math.sqrt(len);
650      k = k >

650 16 ? 16 : k | 0;
651
652      x = x.times(1 / tinyPow(5, k));
653      x = taylorSeries(Ctor, 2, x, x, true);
654
655      // Reverse argument reduction
656      var sinh2_x,
657        d5 = new Ctor(5),
658        d16 = new Ctor(16),
659        d20 = new Ctor(20);
660      for (; k--;) {
661        sinh2_x = x.times(x);
662        x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));
663      }
664    }
665
666    Ctor.precision = pr;
667    Ctor.rounding = rm;
668
669    return finalise(x, pr, rm, true);
670  };
671
672
673  /*
674   * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this
675   * Decimal.
676   *
677   * Domain: [-Infinity, Infinity]
678   * Range: [-1, 1]
679   *
680   * tanh(x) = sinh(x) / cosh(x)
681   *
682   * tanh(0)         = 0
683   * tanh(-0)        = -0
684   * tanh(Infinity)  = 1
685   * tanh(-Infinity) = -1
686   * tanh(NaN)       = NaN
687   *
688   */
689  P.hyperbolicTangent = P.tanh = function () {
690    var pr, rm,
691      x = this,
692      Ctor = x.constructor;
693
694    if (!x.isFinite()) return new Ctor(x.s);
695    if (x.isZero()) return new Ctor(x);
696
697    pr = Ctor.precision;
698    rm = Ctor.rounding;
699    Ctor.precision = pr + 7;
700    Ctor.rounding = 1;
701
702    return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);
703  };
704
705
706  /*
707   * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of
708   * this Decimal.
709   *
710   * Domain: [-1, 1]
711   * Range: [0, pi]
712   *
713   * acos(x) = pi/2 - asin(x)
714   *
715   * acos(0)       = pi/2
716   * acos(-0)      = pi/2
717   * acos(1)       = 0
718   * acos(-1)      = pi
719   * acos(1/2)     = pi/3
720   * acos(-1/2)    = 2*pi/3
721   * acos(|x| > 1) = NaN
722   * acos(NaN)     = NaN
723   *
724   */
725  P.inverseCosine = P.acos = function () {
726    var halfPi,
727      x = this,
728      Ctor = x.constructor,
729      k = x.abs().cmp(1),
730      pr = Ctor.precision,
731      rm = Ctor.rounding;
732
733    if (k !== -1) {
734      return k === 0
735        // |x| is 1
736        ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)
737        // |x| > 1 or x is NaN
738        : new Ctor(NaN);
739    }
740
741    if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);
742
743    // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3
744
745    Ctor.precision = pr + 6;
746    Ctor.rounding = 1;
747
748    x = x.asin();
749    halfPi = getPi(Ctor, pr + 4, rm).times(0.5);
750
751    Ctor.precision = pr;
752    Ctor.rounding = rm;
753
754    return halfPi.minus(x);
755  };
756
757
758  /*
759   * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the
760   * value of this Decimal.
761   *
762   * Domain: [1, Infinity]
763   * Range: [0, Infinity]
764   *
765   * acosh(x) = ln(x + sqrt(x^2 - 1))
766   *
767   * acosh(x < 1)     = NaN
768   * acosh(NaN)       = NaN
769   * acosh(Infinity)  = Infinity
770   * acosh(-Infinity) = NaN
771   * acosh(0)         = NaN
772   * acosh(-0)        = NaN
773   * acosh(1)         = 0
774   * acosh(-1)        = NaN
775   *
776   */
777  P.inverseHyperbolicCosine = P.acosh = function () {
778    var pr, rm,
779      x = this,
780      Ctor = x.constructor;
781
782    if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);
783    if (!x.isFinite()) return new Ctor(x);
784
785    pr = Ctor.precision;
786    rm = Ctor.rounding;
787    Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;
788    Ctor.rounding = 1;
789    external = false;
790
791    x = x.times(x).minus(1).sqrt().plus(x);
792
793    external = true;
794    Ctor.precision = pr;
795    Ctor.rounding = rm;
796
797    return x.ln();
798  };
799
800
801  /*
802   * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value
803   * of this Decimal.
804   *
805   * Domain: [-Infinity, Infinity]
806   * Range: [-Infinity, Infinity]
807   *
808   * asinh(x) = ln(x + sqrt(x^2 + 1))
809   *
810   * asinh(NaN)       = NaN
811   * asinh(Infinity)  = Infinity
812   * asinh(-Infinity) = -Infinity
813   * asinh(0)         = 0
814   * asinh(-0)        = -0
815   *
816   */
817  P.inverseHyperbolicSine = P.asinh = function () {
818    var pr, rm,
819      x = this,
820      Ctor = x.constructor;
821
822    if (!x.isFinite() || x.isZero()) return new Ctor(x);
823
824    pr = Ctor.precision;
825    rm = Ctor.rounding;
826    Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;
827    Ctor.rounding = 1;
828    external = false;
829
830    x = x.times(x).plus(1).sqrt().plus(x);
831
832    external = true;
833    Ctor.precision = pr;
834    Ctor.rounding = rm;
835
836    return x.ln();
837  };
838
839
840  /*
841   * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the
842   * value of this Decimal.
843   *
844   * Domain: [-1, 1]
845   * Range: [-Infinity, Infinity]
846   *
847   * atanh(x) = 0.5 * ln((1 + x) / (1 - x))
848   *
849   * atanh(|x| > 1)   = NaN
850   * atanh(NaN)       = NaN
851   * atanh(Infinity)  = NaN
852   * atanh(-Infinity) = NaN
853   * atanh(0)         = 0
854   * atanh(-0)        = -0
855   * atanh(1)         = Infinity
856   * atanh(-1)        = -Infinity
857   *
858   */
859  P.inverseHyperbolicTangent = P.atanh = function () {
860    var pr, rm, wpr, xsd,
861      x = this,
862      Ctor = x.constructor;
863
864    if (!x.isFinite()) return new Ctor(NaN);
865    if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);
866
867    pr = Ctor.precision;
868    rm = Ctor.rounding;
869    xsd = x.sd();
870
871    if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);
872
873    Ctor.precision = wpr = xsd - x.e;
874
875    x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);
876
877    Ctor.precision = pr + 4;
878    Ctor.rounding = 1;
879
880    x = x.ln();
881
882    Ctor.precision = pr;
883    Ctor.rounding = rm;
884
885    return x.times(0.5);
886  };
887
888
889  /*
890   * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this
891   * Decimal.
892   *
893   * Domain: [-Infinity, Infinity]
894   * Range: [-pi/2, pi/2]
895   *
896   * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))
897   *
898   * asin(0)       = 0
899   * asin(-0)      = -0
900   * asin(1/2)     = pi/6
901   * asin(-1/2)    = -pi/6
902   * asin(1)       = pi/2
903   * asin(-1)      = -pi/2
904   * asin(|x| > 1) = NaN
905   * asin(NaN)     = NaN
906   *
907   * TODO? Compare performance of Taylor series.
908   *
909   */
910  P.inverseSine = P.asin = function () {
911    var halfPi, k,
912      pr, rm,
913      x = this,
914      Ctor = x.constructor;
915
916    if (x.isZero()) return new Ctor(x);
917
918    k = x.abs().cmp(1);
919    pr = Ctor.precision;
920    rm = Ctor.rounding;
921
922    if (k !== -1) {
923
924      // |x| is 1
925      if (k === 0) {
926        halfPi = getPi(Ctor, pr + 4, rm).times(0.5);
927        halfPi.s = x.s;
928        return halfPi;
929      }
930
931      // |x| >

931 1 or x is NaN
932      return new Ctor(NaN);
933    }
934
935    // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6
936
937    Ctor.precision = pr + 6;
938    Ctor.rounding = 1;
939
940    x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();
941
942    Ctor.precision = pr;
943    Ctor.rounding = rm;
944
945    return x.times(2);
946  };
947
948
949  /*
950   * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value
951   * of this Decimal.
952   *
953   * Domain: [-Infinity, Infinity]
954   * Range: [-pi/2, pi/2]
955   *
956   * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...
957   *
958   * atan(0)         = 0
959   * atan(-0)        = -0
960   * atan(1)         = pi/4
961   * atan(-1)        = -pi/4
962   * atan(Infinity)  = pi/2
963   * atan(-Infinity) = -pi/2
964   * atan(NaN)       = NaN
965   *
966   */
967  P.inverseTangent = P.atan = function () {
968    var i, j, k, n, px, t, r, wpr, x2,
969      x = this,
970      Ctor = x.constructor,
971      pr = Ctor.precision,
972      rm = Ctor.rounding;
973
974    if (!x.isFinite()) {
975      if (!x.s) return new Ctor(NaN);
976      if (pr + 4 <= PI_PRECISION) {
977        r = getPi(Ctor, pr + 4, rm).times(0.5);
978        r.s = x.s;
979        return r;
980      }
981    } else if (x.isZero()) {
982      return new Ctor(x);
983    } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {
984      r = getPi(Ctor, pr + 4, rm).times(0.25);
985      r.s = x.s;
986      return r;
987    }
988
989    Ctor.precision = wpr = pr + 10;
990    Ctor.rounding = 1;
991
992    // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);
993
994    // Argument reduction
995    // Ensure |x| < 0.42
996    // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))
997
998    k = Math.min(28, wpr / LOG_BASE + 2 | 0);
999
1000    for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));
1001
1002    external = false;
1003
1004    j = Math.ceil(wpr / LOG_BASE);
1005    n = 1;
1006    x2 = x.times(x);
1007    r = new Ctor(x);
1008    px = x;
1009
1010    // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...
1011    for (; i !== -1;) {
1012      px = px.times(x2);
1013      t = r.minus(px.div(n += 2));
1014
1015      px = px.times(x2);
1016      r = t.plus(px.div(n += 2));
1017
1018      if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);
1019    }
1020
1021    if (k) r = r.times(2 << (k - 1));
1022
1023    external = true;
1024
1025    return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);
1026  };
1027
1028
1029  /*
1030   * Return true if the value of this Decimal is a finite number, otherwise return false.
1031   *
1032   */
1033  P.isFinite = function () {
1034    return !!this.d;
1035  };
1036
1037
1038  /*
1039   * Return true if the value of this Decimal is an integer, otherwise return false.
1040   *
1041   */
1042  P.isInteger = P.isInt = function () {
1043    return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;
1044  };
1045
1046
1047  /*
1048   * Return true if the value of this Decimal is NaN, otherwise return false.
1049   *
1050   */
1051  P.isNaN = function () {
1052    return !this.s;
1053  };
1054
1055
1056  /*
1057   * Return true if the value of this Decimal is negative, otherwise return false.
1058   *
1059   */
1060  P.isNegative = P.isNeg = function () {
1061    return this.s < 0;
1062  };
1063
1064
1065  /*
1066   * Return true if the value of this Decimal is positive, otherwise return false.
1067   *
1068   */
1069  P.isPositive = P.isPos = function () {
1070    return this.s > 0;
1071  };
1072
1073
1074  /*
1075   * Return true if the value of this Decimal is 0 or -0, otherwise return false.
1076   *
1077   */
1078  P.isZero = function () {
1079    return !!this.d && this.d[0] === 0;
1080  };
1081
1082
1083  /*
1084   * Return true if the value of this Decimal is less than `y`, otherwise return false.
1085   *
1086   */
1087  P.lessThan = P.lt = function (y) {
1088    return this.cmp(y) < 0;
1089  };
1090
1091
1092  /*
1093   * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.
1094   *
1095   */
1096  P.lessThanOrEqualTo = P.lte = function (y) {
1097    return this.cmp(y) < 1;
1098  };
1099
1100
1101  /*
1102   * Return the logarithm of the value of this Decimal to the specified base, rounded to `precision`

1246   *  n - I = -I
1247   *  0 - n = -n
1248   *  0 - 0 = 0
1249   *  0 - N = N
1250   *  0 - I = -I
1251   *  N - n = N
1252   *  N - 0 = N
1253   *  N - N = N
1254   *  N - I = N
1255   *  I - n = I
1256   *  I - 0 = I
1257   *  I - N = N
1258   *  I - I = N
1259   *
1260   * Return a new Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`
1261   * significant digits using rounding mode `rounding`.
1262   *
1263   */
1264  P.minus = P.sub = function (y) {
1265    var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,
1266      x = this,
1267      Ctor = x.constructor;
1268
1269    y = new Ctor(y);
1270
1271    // If either is not finite...
1272    if (!x.d || !y.d) {
1273
1274      // Return NaN if either is NaN.
1275      if (!x.s || !y.s) y = new Ctor(NaN);
1276
1277      // Return y negated if x is finite and y is ±Infinity.
1278      else if (x.d) y.s = -y.s;
1279
1280      // Return x if y is finite and x is ±Infinity.
1281      // Return x if both are ±Infinity with different signs.
1282      // Return NaN if both are ±Infinity with the same sign.
1283      else y = new Ctor(y.d || x.s !== y.s ? x : NaN);
1284
1285      return y;
1286    }
1287
1288    // If signs differ...
1289    if (x.s != y.s) {
1290      y.s = -y.s;
1291      return x.plus(y);
1292    }
1293
1294    xd = x.d;
1295    yd = y.d;
1296    pr = Ctor.precision;
1297    rm = Ctor.rounding;
1298
1299    // If either is zero...
1300    if (!xd[0] || !yd[0]) {
1301
1302      // Return y negated if x is zero and y is non-zero.
1303      if (yd[0]) y.s = -y.s;
1304
1305      // Return x if y is zero and x is non-zero.
1306      else if (xd[0]) y = new Ctor(x);
1307
1308      // Return zero if both are zero.
1309      // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.
1310      else return new Ctor(rm === 3 ? -0 : 0);
1311
1312      return external ? finalise(y, pr, rm) : y;
1313    }
1314
1315    // x and y are finite, non-zero numbers with the same sign.
1316
1317    // Calculate base 1e7 exponents.
1318    e = mathfloor(y.e / LOG_BASE);
1319    xe = mathfloor(x.e / LOG_BASE);
1320
1321    xd = xd.slice();
1322    k = xe - e;
1323
1324    // If base 1e7 exponents differ...
1325    if (k) {
1326      xLTy = k < 0;
1327
1328      if (xLTy) {
1329        d = xd;
1330        k = -k;
1331        len = yd.length;
1332      } else {
1333        d = yd;
1334        e = xe;
1335        len = xd.length;
1336      }
1337
1338      // Numbers with massively different exponents would result in a very high number of
1339      // zeros needing to be prepended, but this can be avoided while still ensuring correct
1340      // rounding by limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.
1341      i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;
1342
1343      if (k > i) {
1344        k = i;
1345        d.length = 1;
1346      }
1347
1348      // Prepend zeros to equalise exponents.
1349      d.reverse();
1350      for (i = k; i--;) d.push(0);
1351      d.reverse();
1352
1353    // Base 1e7 exponents equal.
1354    } else {
1355
1356      // Check digits to determine which is the bigger number.
1357
1358      i = xd.length;
1359      len = yd.length;
1360      xLTy = i < len;
1361      if (xLTy) len = i;
1362
1363      for (i = 0; i < len; i++) {
1364        if (xd[i] != yd[i]) {
1365          xLTy = xd[i] < yd[i];
1366          break;
1367        }
1368      }
1369
1370      k = 0;
1371    }
1372
1373    if (xLTy) {
1374      d = xd;
1375      xd = yd;
1376      yd = d;
1377      y.s = -y.s;
1378    }
1379
1380    len = xd.length;
1381
1382    // Append zeros to `xd` if shorter.
1383    // Don't add zeros to `yd` if shorter as subtraction only needs to start at `yd` length.
1384    for (i = yd.length - len; i > 0; --i) xd[len++] = 0;
1385
1386    // Subtract yd from xd.
1387    for (i = yd.length; i > k;) {
1388
1389      if (xd[--i] < yd[i]) {
1390        for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;
1391        --xd[j];
1392        xd[i] += BASE;
1393      }
1394
1395      xd[i] -= yd[i];
1396    }
1397
1398    // Remove trailing zeros.
1399    for (; xd[--len] === 0;) xd.pop();
1400
1401    // Remove leading zeros and adjust exponent accordingly.
1402    for (; xd[0] === 0; xd.shift()) --e;
1403
1404    // Zero?
1405    if (!xd[0]) return new Ctor(rm === 3 ? -0 : 0);
1406
1407    y.d = xd;
1408    y.e = getBase10Exponent(xd, e);
1409
1410    return external ? finalise(y, pr, rm) : y;
1411  };
1412
1413
1414  /*
1415   *   n % 0 =  N
1416   *   n % N =  N
1417   *   n % I =  n
1418   *   0 % n =  0
1419   *  -0 % n = -0
1420   *   0 % 0 =  N
1421   *   0 % N =  N
1422   *   0 % I =  0
1423   *   N % n =  N
1424   *   N % 0 =  N
1425   *   N % N =  N
1426   *   N % I =  N
1427   *   I % n =  N
1428   *   I % 0 =  N
1429   *   I % N =  N
1430   *   I % I =  N
1431   *
1432   * Return a new Decimal whose value is the value of this Decimal modulo `y`, rounded to
1433   * `precision` significant digits using rounding mode `rounding`.
1434   *
1435   * The result depends on the modulo mode.
1436   *
1437   */
1438  P.modulo = P.mod = function (y) {
1439    var q,
1440      x = this,
1441      Ctor = x.constructor;
1442
1443    y = new Ctor(y);
1444
1445    // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.
1446    if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);
1447
1448    // Return x if y is ±Infinity or x is ±0.
1449    if (!y.d || x.d && !x.d[0]) {
1450      return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);
1451    }
1452
1453    // Prevent rounding of intermediate calculations.
1454    external = false;
1455
1456    if (Ctor.modulo == 9) {
1457
1458      // Euclidian division: q = sign(y) * floor(x / abs(y))
1459      // result = x - q * y    where  0 <= result < abs(y)
1460      q = divide(x, y.abs(), 0, 3, 1);
1461      q.s *= y.s;
1462    } else {
1463      q = divide(x, y, 0, Ctor.modulo, 1);
1464    }
1465
1466    q = q.times(y);
1467
1468    external = true;
1469
1470    return x.minus(q);
1471  };
1472
1473
1474  /*
1475   * Return a new Decimal whose value is the natural exponential of the value of this Decimal,
1476   * i.e. the base e raised to the power the value of this Decimal, rounded to `precision`

1525   * significant digits using rounding mode `rounding`.
1526   *
1527   */
1528  P.plus = P.add = function (y) {
1529    var carry, d, e, i, k, len, pr, rm, xd, yd,
1530      x = this,
1531      Ctor = x.constructor;
1532
1533    y = new Ctor(y);
1534
1535    // If either is not finite...
1536    if (!x.d || !y.d) {
1537
1538      // Return NaN if either is NaN.
1539      if (!x.s || !y.s) y = new Ctor(NaN);
1540
1541      // Return x if y is finite and x is ±Infinity.
1542      // Return x if both are ±Infinity with the same sign.
1543      // Return NaN if both are ±Infinity with different signs.
1544      // Return y if x is finite and y is ±Infinity.
1545      else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);
1546
1547      return y;
1548    }
1549
1550     // If signs differ...
1551    if (x.s != y.s) {
1552      y.s = -y.s;
1553      return x.minus(y);
1554    }
1555
1556    xd = x.d;
1557    yd = y.d;
1558    pr = Ctor.precision;
1559    rm = Ctor.rounding;
1560
1561    // If either is zero...
1562    if (!xd[0] || !yd[0]) {
1563
1564      // Return x if y is zero.
1565      // Return y if y is non-zero.
1566      if (!yd[0]) y = new Ctor(x);
1567
1568      return external ? finalise(y, pr, rm) : y;
1569    }
1570
1571    // x and y are finite, non-zero numbers with the same sign.
1572
1573    // Calculate base 1e7 exponents.
1574    k = mathfloor(x.e / LOG_BASE);
1575    e = mathfloor(y.e / LOG_BASE);
1576
1577    xd = xd.slice();
1578    i = k - e;
1579
1580    // If base 1e7 exponents differ...
1581    if (i) {
1582
1583      if (i < 0) {
1584        d = xd;
1585        i = -i;
1586        len = yd.length;
1587      } else {
1588        d = yd;
1589        e = k;
1590        len = xd.length;
1591      }
1592
1593      // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.
1594      k = Math.ceil(pr / LOG_BASE);
1595      len = k > len ? k + 1 : len + 1;
1596
1597      if (i > len) {
1598        i = len;
1599        d.length = 1;
1600      }
1601
1602      // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.
1603      d.reverse();
1604      for (; i--;) d.push(0);
1605      d.reverse();
1606    }
1607
1608    len = xd.length;
1609    i = yd.length;
1610
1611    // If yd is longer than xd, swap xd and yd so xd points to the longer array.
1612    if (len - i < 0) {
1613      i = len;
1614      d = yd;
1615      yd = xd;
1616      xd = d;
1617    }
1618
1619    // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.
1620    for (carry = 0; i;) {
1621      carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;
1622      xd[i] %= BASE;
1623    }
1624
1625    if (carry) {
1626      xd.unshift(carry);
1627      ++e;
1628    }
1629
1630    // Remove trailing zeros.
1631    // No need to check for zero, as +x + +y != 0 && -x + -y != 0
1632    for (len = xd.length; xd[--len] == 0;) xd.pop();
1633
1634    y.d = xd;
1635    y.e = getBase10Exponent(xd, e);
1636
1637    return external ? finalise(y, pr, rm) : y;
1638  };
1639
1640
1641  /*
1642   * Return the number of significant digits of the value of this Decimal.
1643   *
1644   * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.
1645   *
1646   */
1647  P.precision = P.sd = function (z) {
1648    var k,
1649      x = this;
1650
1651    if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);
1652
1653    if (x.d) {
1654      k = getPrecision(x.d);
1655      if (z && x.e + 1 > k) k = x.e + 1;
1656    } else {
1657      k = NaN;
1658    }
1659
1660    return k;
1661  };
1662
1663
1664  /*
1665   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using
1666   * rounding mode `rounding`.
1667   *
1668   */
1669  P.round = function () {
1670    var x = this,
1671      Ctor = x.constructor;
1672
1673    return finalise(new Ctor(x), x.e + 1, Ctor.rounding);
1674  };
1675
1676
1677  /*
1678   * Return a new Decimal whose value is the sine of the value in radians of this Decimal.
1679   *
1680   * Domain: [-Infinity, Infinity]
1681   * Range: [-1, 1]
1682   *
1683   * sin(x) = x - x^3/3! + x^5/5! - ...
1684   *
1685   * sin(0)         = 0
1686   * sin(-0)        = -0
1687   * sin(Infinity)  = NaN
1688   * sin(-Infinity) = NaN
1689   * sin(NaN)       = NaN
1690   *
1691   */
1692  P.sine = P.sin = function () {
1693    var pr, rm,
1694      x = this,
1695      Ctor = x.constructor;
1696
1697    if (!x.isFinite()) return new Ctor(NaN);
1698    if (x.isZero()) return new Ctor(x);
1699
1700    pr = Ctor.precision;
1701    rm = Ctor.rounding;
1702    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;
1703    Ctor.rounding = 1;
1704
1705    x = sine(Ctor, toLessThanHalfPi(Ctor, x));
1706
1707    Ctor.precision = pr;
1708    Ctor.rounding = rm;
1709
1710    return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);
1711  };
1712
1713
1714  /*
1715   * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`
1716   * significant digits using rounding mode `rounding`.
1717   *
1718   *  sqrt(-n) =  N
1719   *  sqrt(N)  =  N
1720   *  sqrt(-I) =  N
1721   *  sqrt(I)  =  I
1722   *  sqrt(0)  =  0
1723   *  sqrt(-0) = -0
1724   *
1725   */
1726  P.squareRoot = P.sqrt = function () {
1727    var m, n, sd, r, rep, t,
1728      x = this,
1729      d = x.d,
1730      e = x.e,
1731      s = x.s,
1732      Ctor = x.constructor;
1733
1734    // Negative/NaN/Infinity/zero?
1735    if (s !== 1 || !d || !d[0]) {
1736      return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);
1737    }
1738
1739    external = false;
1740
1741    // Initial estimate.
1742    s = Math.sqrt(+x);
1743
1744    // Math.sqrt underflow/overflow?
1745    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.
1746    if (s == 0 || s == 1 / 0) {
1747      n = digitsToString(d);
1748
1749      if ((n.length + e) % 2 == 0) n += '0';
1750      s = Math.sqrt(n);
1751      e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);
1752
1753      if (s == 1 / 0) {
1754        n = '5e' + e;
1755      } else {
1756        n = s.toExponential();
1757        n = n.slice(0, n.indexOf('e') + 1) + e;
1758      }
1759
1760      r = new Ctor(n);
1761    } else {
1762      r = new Ctor(s.toString());
1763    }
1764
1765    sd = (e = Ctor.precision) + 3;
1766
1767    // Newton-Raphson iteration.
1768    for (;;) {
1769      t = r;
1770      r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);
1771
1772      // TODO? Replace with for-loop and checkRoundingDigits.
1773      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {
1774        n = n.slice(sd - 3, sd + 1);
1775
1776        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or
1777        // 4999, i.e. approaching a rounding boundary, continue the iteration.
1778        if (n == '9999' || !rep && n == '4999') {
1779
1780          // On the first iteration only, check to see if rounding up gives the exact result as the
1781          // nines may infinitely repeat.
1782          if (!rep) {
1783            finalise(t, e + 1, 0);
1784
1785            if (t.times(t).eq(x)) {
1786              r = t;
1787              break;
1788            }
1789          }
1790
1791          sd += 4;
1792          rep = 1;
1793        } else {
1794
1795          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.
1796          // If not, then there are further digits and m will be truthy.
1797          if (!+n || !+n.slice(1) && n.charAt(0) == '5') {
1798
1799            // Truncate to the first rounding digit.
1800            finalise(r, e + 1, 1);
1801            m = !r.times(r).eq(x);
1802          }
1803
1804          break;
1805        }
1806      }
1807    }
1808
1809    external = true;
1810
1811    return finalise(r, e, Ctor.rounding, m);
1812  };
1813
1814
1815  /*
1816   * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.
1817   *
1818   * Domain: [-Infinity, Infinity]
1819   * Range: [-Infinity, Infinity]
1820   *
1821   * tan(0)         = 0
1822   * tan(-0)        = -0
1823   * tan(Infinity)  = NaN
1824   * tan(-Infinity) = NaN
1825   * tan(NaN)       = NaN
1826   *
1827   */
1828  P.tangent = P.tan = function () {
1829    var pr, rm,
1830      x = this,
1831      Ctor = x.constructor;
1832
1833    if (!x.isFinite()) return new Ctor(NaN);
1834    if (x.isZero()) return new Ctor(x);
1835
1836    pr = Ctor.precision;
1837    rm = Ctor.rounding;
1838    Ctor.precision = pr + 10;
1839    Ctor.rounding = 1;
1840
1841    x = x.sin();
1842    x.s = 1;
1843    x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);
1844
1845    Ctor.precision = pr;
1846    Ctor.rounding = rm;
1847
1848    return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);
1849  };
1850
1851
1852  /*
1853   *  n * 0 = 0
1854   *  n * N = N
1855   *  n * I = I
1856   *  0 * n = 0
1857   *  0 * 0 = 0
1858   *  0 * N = N
1859   *  0 * I = N
1860   *  N * n = N
1861   *  N * 0 = N
1862   *  N * N = N
1863   *  N * I = N
1864   *  I * n = I
1865   *  I * 0 = N
1866   *  I * N = N
1867   *  I * I = I
1868   *
1869   * Return a new Decimal whose value is this Decimal times `y`, rounded to `precision` significant
1870   * digits using rounding mode `rounding`.
1871   *
1872   */
1873  P.times = P.mul = function (y) {
1874    var carry, e, i, k, r, rL, t, xdL, ydL,
1875      x = this,
1876      Ctor = x.constructor,
1877      xd = x.d,
1878      yd = (y = new Ctor(y)).d;
1879
1880    y.s *= x.s;
1881
1882     // If either is NaN, ±Infinity or ±0...
1883    if (!xd || !xd[0] || !yd || !yd[0]) {
1884
1885      return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd
1886
1887        // Return NaN if either is NaN.
1888        // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.
1889        ? NaN
1890
1891        // Return ±Infinity if either is ±Infinity.
1892        // Return ±0 if either is ±0.
1893        : !xd || !yd ? y.s / 0 : y.s * 0);
1894    }
1895
1896    e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);
1897    xdL = xd.length;
1898    ydL = yd.length;
1899
1900    // Ensure xd points to the longer array.
1901    if (xdL < ydL) {
1902      r = xd;
1903      xd = yd;
1904      yd = r;
1905      rL = xdL;
1906      xdL = ydL;
1907      ydL = rL;
1908    }
1909
1910    // Initialise the result array with zeros.
1911    r = [];
1912    rL = xdL + ydL;
1913    for (i = rL; i--;) r.push(0);
1914
1915    // Multiply!
1916    for (i = ydL; --i >= 0;) {
1917      carry = 0;
1918      for (k = xdL + i; k > i;) {
1919        t = r[k] + yd[i] * xd[k - i - 1] + carry;
1920        r[k--] = t % BASE | 0;
1921        carry = t / BASE | 0;
1922      }
1923
1924      r[k] = (r[k] + carry) % BASE | 0;
1925    }
1926
1927    // Remove trailing zeros.
1928    for (; !r[--rL];) r.pop();
1929
1930    if (carry) ++e;
1931    else r.shift();
1932
1933    y.d = r;
1934    y.e = getBase10Exponent(r, e);
1935
1936    return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;
1937  };
1938
1939
1940  /*
1941   * Return a string representing the value of this Decimal in base 2, round to `sd` significant
1942   * digits using rounding mode `rm`.
1943   *
1944   * If the optional `sd` argument is present then return binary exponential notation.
1945   *
1946   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
1947   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
1948   *
1949   */
1950  P.toBinary = function (sd, rm) {
1951    return toStringBinary(this, 2, sd, rm);
1952  };
1953
1954
1955  /*
1956   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`
1957   * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.
1958   *
1959   * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.
1960   *
1961   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
1962   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
1963   *
1964   */
1965  P.toDecimalPlaces = P.toDP = function (dp, rm) {
1966    var x = this,
1967      Ctor = x.constructor;
1968
1969    x = new Ctor(x);
1970    if (dp === void 0) return x;
1971
1972    checkInt32(dp, 0, MAX_DIGITS);
1973
1974    if (rm === void 0) rm = Ctor.rounding;
1975    else checkInt32(rm, 0, 8);
1976
1977    return finalise(x, dp + x.e + 1, rm);
1978  };
1979
1980
1981  /*
1982   * Return a string representing the value of this Decimal in exponential notation rounded to
1983   * `dp` fixed decimal places using rounding mode `rounding`.
1984   *
1985   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
1986   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
1987   *
1988   */
1989  P.toExponential = function (dp, rm) {
1990    var str,
1991      x = this,
1992      Ctor = x.constructor;
1993
1994    if (dp === void 0) {
1995      str = finiteToString(x, true);
1996    } else {
1997      checkInt32(dp, 0, MAX_DIGITS);
1998
1999      if (rm === void 0) rm = Ctor.rounding;
2000      else checkInt32(rm, 0, 8);
2001
2002      x = finalise(new Ctor(x), dp + 1, rm);
2003      str = finiteToString(x, true, dp + 1);
2004    }
2005
2006    return x.isNeg() && !x.isZero() ? '-' + str : str;
2007  };
2008
2009
2010  /*
2011   * Return a string representing the value of this Decimal in normal (fixed-point) notation to
2012   * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is
2013   * omitted.
2014   *
2015   * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.
2016   *
2017   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
2018   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
2019   *
2020   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
2021   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
2022   * (-0).toFixed(3) is '0.000'.
2023   * (-0.5).toFixed(0) is '-0'.
2024   *
2025   */
2026  P.toFixed = function (dp, rm) {
2027    var str, y,
2028      x = this,
2029      Ctor = x.constructor;
2030
2031    if (dp === void 0) {
2032      str = finiteToString(x);
2033    } else {
2034      checkInt32(dp, 0, MAX_DIGITS);
2035
2036      if (rm === void 0) rm = Ctor.rounding;
2037      else checkInt32(rm, 0, 8);
2038
2039      y = finalise(new Ctor(x), dp + x.e + 1, rm);
2040      str = finiteToString(y, false, dp + y.e + 1);
2041    }
2042
2043    // To determine whether to add the minus sign look at the value before it was rounded,
2044    // i.e. look at `x` rather than `y`.
2045    return x.isNeg() && !x.isZero() ? '-' + str : str;
2046  };
2047
2048
2049  /*
2050   * Return an array representing the value of this Decimal as a simple fraction with an integer
2051   * numerator and an integer denominator.
2052   *
2053   * The denominator will be a positive non-zero value less than or equal to the specified maximum
2054   * denominator. If a maximum denominator is not specified, the denominator will be the lowest
2055   * value necessary to represent the number exactly.
2056   *
2057   * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.
2058   *
2059   */
2060  P.toFraction = function (maxD) {
2061    var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,
2062      x = this,
2063      xd = x.d,
2064      Ctor = x.constructor;
2065
2066    if (!xd) return new Ctor(x);
2067
2068    n1 = d0 = new Ctor(1);
2069    d1 = n0 = new Ctor(0);
2070
2071    d = new Ctor(d1);
2072    e = d.e = getPrecision(xd) - x.e - 1;
2073    k = e % LOG_BASE;
2074    d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);
2075
2076    if (maxD == null) {
2077
2078      // d is 10**e, the minimum max-denominator needed.
2079      maxD = e > 0 ? d : n1;
2080    } else {
2081      n = new Ctor(maxD);
2082      if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);
2083      maxD = n.gt(d) ? (e > 0 ? d : n1) : n;
2084    }
2085
2086    external = false;
2087    n = new Ctor(digitsToString(xd));
2088    pr = Ctor.precision;
2089    Ctor.precision = e = xd.length * LOG_BASE * 2;
2090
2091    for (;;)  {
2092      q = divide(n, d, 0, 1, 1);
2093      d2 = d0.plus(q.times(d1));
2094      if (d2.cmp(maxD) == 1) break;
2095      d0 = d1;
2096      d1 = d2;
2097      d2 = n1;
2098      n1 = n0.plus(q.times(d2));
2099      n0 = d2;
2100      d2 = d;
2101      d = n.minus(q.times(d2));
2102      n = d2;
2103    }
2104
2105    d2 = divide(maxD.minus(d0), d1, 0, 1, 1);
2106    n0 = n0.plus(d2.times(n1));
2107    d0 = d0.plus(d2.times(d1));
2108    n0.s = n1.s = x.s;
2109
2110    // Determine which fraction is closer to x, n0/d0 or n1/d1?
2111    r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1
2112        ? [n1, d1] : [n0, d0];
2113
2114    Ctor.precision = pr;
2115    external = true;
2116
2117    return r;
2118  };
2119
2120
2121  /*
2122   * Return a string representing the value of this Decimal in base 16, round to `sd` significant
2123   * digits using rounding mode `rm`.
2124   *
2125   * If the optional `sd` argument is present then return binary exponential notation.
2126   *
2127   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
2128   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
2129   *
2130   */
2131  P.toHexadecimal = P.toHex = function (sd, rm) {
2132    return toStringBinary(this, 16, sd, rm);
2133  };
2134
2135
2136  /*
2137   * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding
2138   * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.
2139   *
2140   * The return value will always have the same sign as this Decimal, unless either this Decimal
2141   * or `y` is NaN, in which case the return value will be also be NaN.
2142   *
2143   * The return value is not affected by the value of `precision`.
2144   *
2145   * y {number|string|Decimal} The magnitude to round to a multiple of.
2146   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
2147   *
2148   * 'toNearest() rounding mode not an integer: {rm}'
2149   * 'toNearest() rounding mode out of range: {rm}'
2150   *
2151   */
2152  P.toNearest = function (y, rm) {
2153    var x = this,
2154      Ctor = x.constructor;
2155
2156    x = new Ctor(x);
2157
2158    if (y == null) {
2159
2160      // If x is not finite, return x.
2161      if (!x.d) return x;
2162
2163      y = new Ctor(1);
2164      rm = Ctor.rounding;
2165    } else {
2166      y = new Ctor(y);
2167      if (rm === void 0) {
2168        rm = Ctor.rounding;
2169      } else {
2170        checkInt32(rm, 0, 8);
2171      }
2172
2173      // If x is not finite, return x if y is not NaN, else NaN.
2174      if (!x.d) return y.s ? x : y;
2175
2176      // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.
2177      if (!y.d) {
2178        if (y.s) y.s = x.s;
2179        return y;
2180      }
2181    }
2182
2183    // If y is not zero, calculate the nearest multiple of y to x.
2184    if (y.d[0]) {
2185      external = false;
2186      x = divide(x, y, 0, rm, 1).times(y);
2187      external = true;
2188      finalise(x);
2189
2190    // If y is zero, return zero with the sign of x.
2191    } else {
2192      y.s = x.s;
2193      x = y;
2194    }
2195
2196    return x;
2197  };
2198
2199
2200  /*
2201   * Return the value of this Decimal converted to a number primitive.
2202   * Zero keeps its sign.
2203   *
2204   */
2205  P.toNumber = function () {
2206    return +this;
2207  };
2208
2209
2210  /*
2211   * Return a string representing the value of this Decimal in base 8, round to `sd` significant
2212   * digits using rounding mode `rm`.
2213   *
2214   * If the optional `sd` argument is present then return binary exponential notation.
2215   *
2216   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
2217   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
2218   *
2219   */
2220  P.toOctal = function (sd, rm) {
2221    return toStringBinary(this, 8, sd, rm);
2222  };
2223
2224
2225  /*
2226   * Return a new Decimal whose value is the value of this Decimal raised to the power `y`, rounded
2227   * to `precision` significant digits using rounding mode `rounding`.
2228   *
2229   * ECMAScript compliant.
2230   *
2231   *   pow(x, NaN)                           = NaN
2232   *   pow(x, ±0)                            = 1
2233
2234   *   pow(NaN, non-zero)                    = NaN
2235   *   pow(abs(x) > 1, +Infinity)            = +Infinity
2236   *   pow(abs(x) > 1, -Infinity)            = +0
2237   *   pow(abs(x) == 1, ±Infinity)           = NaN
2238   *   pow(abs(x) < 1, +Infinity)            = +0
2239   *   pow(abs(x) < 1, -Infinity)            = +Infinity
2240   *   pow(+Infinity, y > 0)                 = +Infinity
2241   *   pow(+Infinity, y < 0)                 = +0
2242   *   pow(-Infinity, odd integer > 0)       = -Infinity
2243   *   pow(-Infinity, even integer > 0)      = +Infinity
2244   *   pow(-Infinity, odd integer < 0)       = -0
2245   *   pow(-Infinity, even integer < 0)      = +0
2246   *   pow(+0, y > 0)                        = +0
2247   *   pow(+0, y < 0)                        = +Infinity
2248   *   pow(-0, odd integer > 0)              = -0
2249   *   pow(-0, even integer > 0)             = +0
2250   *   pow(-0, odd integer < 0)              = -Infinity
2251   *   pow(-0, even integer < 0)             = +Infinity
2252   *   pow(finite x < 0, finite non-integer) = NaN
2253   *
2254   * For non-integer or very large exponents pow(x, y) is calculated using
2255   *
2256   *   x^y = exp(y*ln(x))
2257   *
2258   * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the
2259   * probability of an incorrectly rounded result
2260   * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14
2261   * i.e. 1 in 250,000,000,000,000
2262   *
2263   * If a result is incorrectly rounded the maximum error will be 1 ulp (unit in last place).
2264   *
2265   * y {number|string|Decimal} The power to which to raise this Decimal.
2266   *
2267   */
2268  P.toPower = P.pow = function (y) {
2269    var e, k, pr, r, rm, s,
2270      x = this,
2271      Ctor = x.constructor,
2272      yn = +(y = new Ctor(y));
2273
2274    // Either ±Infinity, NaN or ±0?
2275    if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));
2276
2277    x = new Ctor(x);
2278
2279    if (x.eq(1)) return x;
2280
2281    pr = Ctor.precision;
2282    rm = Ctor.rounding;
2283
2284    if (y.eq(1)) return finalise(x, pr, rm);
2285
2286    // y exponent
2287    e = mathfloor(y.e / LOG_BASE);
2288
2289    // If y is a small integer use the 'exponentiation by squaring' algorithm.
2290    if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {
2291      r = intPow(Ctor, x, k, pr);
2292      return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);
2293    }
2294
2295    s = x.s;
2296
2297    // if x is negative
2298    if (s < 0) {
2299
2300      // if y is not an integer
2301      if (e < y.d.length - 1) return new Ctor(NaN);
2302
2303      // Result is positive if x is negative and the last digit of integer y is even.
2304      if ((y.d[e] & 1) == 0) s = 1;
2305
2306      // if x.eq(-1)
2307      if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {
2308        x.s = s;
2309        return x;
2310      }
2311    }
2312
2313    // Estimate result exponent.
2314    // x^y = 10^e,  where e = y * log10(x)
2315    // log10(x) = log10(x_significand) + x_exponent
2316    // log10(x_significand) = ln(x_significand) / ln(10)
2317    k = mathpow(+x, yn);
2318    e = k == 0 || !isFinite(k)
2319      ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))
2320      : new Ctor(k + '').e;
2321
2322    // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.
2323
2324    // Overflow/underflow?
2325    if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);
2326
2327    external = false;
2328    Ctor.rounding = x.s = 1;
2329
2330    // Estimate the extra guard digits needed to ensure five correct rounding digits from
2331    // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):
2332    // new Decimal(2.32456).pow('2087987436534566.46411')
2333    // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815
2334    k = Math.min(12, (e + '').length);
2335
2336    // r = x^y = exp(y*ln(x))
2337    r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);
2338
2339    // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)
2340    if (r.d) {
2341
2342      // Truncate to the required precision plus five rounding digits.
2343      r = finalise(r, pr + 5, 1);
2344
2345      // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate
2346      // the result.
2347      if (checkRoundingDigits(r.d, pr, rm)) {
2348        e = pr + 10;
2349
2350        // Truncate to the increased precision plus five rounding digits.
2351        r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);
2352
2353        // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).
2354        if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {
2355          r = finalise(r, pr + 1, 0);
2356        }
2357      }
2358    }
2359
2360    r.s = s;
2361    external = true;
2362    Ctor.rounding = rm;
2363
2364    return finalise(r, pr, rm);
2365  };
2366
2367
2368  /*
2369   * Return a string representing the value of this Decimal rounded to `sd` significant digits

2495   *  getBase10Exponent        P.minus, P.plus, P.times, parseOther
2496   *  getLn10                  P.logarithm, naturalLogarithm
2497   *  getPi                    P.acos, P.asin, P.atan, toLessThanHalfPi, atan2
2498   *  getPrecision             P.precision, P.toFraction
2499   *  getZeroString            digitsToString, finiteToString
2500   *  intPow                   P.toPower, parseOther
2501   *  isOdd                    toLessThanHalfPi
2502   *  maxOrMin                 max, min
2503   *  naturalExponential       P.naturalExponential, P.toPower
2504   *  naturalLogarithm         P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,
2505   *                           P.toPower, naturalExponential
2506   *  nonFiniteToString        finiteToString, toStringBinary
2507   *  parseDecimal             Decimal
2508   *  parseOther               Decimal
2509   *  sin                      P.sin
2510   *  taylorSeries             P.cosh, P.sinh, cos, sin
2511   *  toLessThanHalfPi         P.cos, P.sin
2512   *  toStringBinary           P.toBinary, P.toHexadecimal, P.toOctal
2513   *  truncate                 intPow
2514   *
2515   *  Throws:                  P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,
2516   *                           naturalLogarithm, config, parseOther, random, Decimal
2517   */
2518
2519
2520  function digitsToString(d) {
2521    var i, k, ws,
2522      indexOfLastWord = d.length - 1,
2523      str = '',
2524      w = d[0];
2525
2526    if (indexOfLastWord > 0) {
2527      str += w;
2528      for (i = 1; i < indexOfLastWord; i++) {
2529        ws = d[i] + '';
2530        k = LOG_BASE - ws.length;
2531        if (k) str += getZeroString(k);
2532        str += ws;
2533      }
2534
2535      w = d[i];
2536      ws = w + '';
2537      k = LOG_BASE - ws.length;
2538      if (k) str += getZeroString(k);
2539    } else if (w === 0) {
2540      return '0';
2541    }
2542
2543    // Remove trailing zeros of last w.
2544    for (; w % 10 === 0;) w /= 10;
2545
2546    return str + w;
2547  }
2548
2549
2550  function checkInt32(i, min, max) {
2551    if (i !== ~~i || i < min || i > max) {
2552      throw Error(invalidArgument + i);
2553    }
2554  }
2555
2556
2557  /*
2558   * Check 5 rounding digits if `repeating` is null, 4 otherwise.
2559   * `repeating == null` if caller is `log` or `pow`,
2560   * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.
2561   */
2562  function checkRoundingDigits(d, i, rm, repeating) {
2563    var di, k, r, rd;
2564
2565    // Get the length of the first word of the array d.
2566    for (k = d[0]; k >= 10; k /= 10) --i;
2567
2568    // Is the rounding digit in the first word of d?
2569    if (--i < 0) {
2570      i += LOG_BASE;
2571      di = 0;
2572    } else {
2573      di = Math.ceil((i + 1) / LOG_BASE);
2574      i %= LOG_BASE;
2575    }
2576
2577    // i is the index (0 - 6) of the rounding digit.
2578    // E.g. if within the word 3487563 the first rounding digit is 5,
2579    // then i = 4, k = 1000, rd = 3487563 % 1000 = 563
2580    k = mathpow(10, LOG_BASE - i);
2581    rd = d[di] % k | 0;
2582
2583    if (repeating == null) {
2584      if (i < 3) {
2585        if (i == 0) rd = rd / 100 | 0;
2586        else if (i == 1) rd = rd / 10 | 0;
2587        r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;
2588      } else {
2589        r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&
2590          (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||
2591            (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;
2592      }
2593    } else {
2594      if (i < 4) {
2595        if (i == 0) rd = rd / 1000 | 0;
2596        else if (i == 1) rd = rd / 100 | 0;
2597        else if (i == 2) rd = rd / 10 | 0;
2598        r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;
2599      } else {
2600        r = ((repeating || rm < 4) && rd + 1 == k ||
2601        (!repeating && rm > 3) && rd + 1 == k / 2) &&
2602          (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;
2603      }
2604    }
2605
2606    return r;
2607  }
2608
2609
2610  // Convert string of `baseIn` to an array of numbers of `baseOut`.
2611  // Eg. convertBase('255', 10, 16) returns [15, 15].
2612  // Eg. convertBase('ff', 16, 10) returns [2, 5, 5].
2613  function convertBase(str, baseIn, baseOut) {
2614    var j,
2615      arr = [0],
2616      arrL,
2617      i = 0,
2618      strL = str.length;
2619
2620    for (; i < strL;) {
2621      for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;
2622      arr[0] += NUMERALS.indexOf(str.charAt(i++));
2623      for (j = 0; j < arr.length; j++) {
2624        if (arr[j] > baseOut - 1) {
2625          if (arr[j + 1] === void 0) arr[j + 1] = 0;
2626          arr[j + 1] += arr[j] / baseOut | 0;
2627          arr[j] %= baseOut;
2628        }
2629      }
2630    }
2631
2632    return arr.reverse();
2633  }
2634
2635
2636  /*
2637   * cos(x) = 1 - x^2/2! + x^4/4! - ...
2638   * |x| < pi/2
2639   *
2640   */
2641  function cosine(Ctor, x) {
2642    var k, len, y;
2643
2644    if (x.isZero()) return x;
2645
2646    // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1
2647    // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1
2648
2649    // Estimate the optimum number of times to use the argument reduction.
2650    len = x.d.length;
2651    if (len < 32) {
2652      k = Math.ceil(len / 3);
2653      y = (1 / tinyPow(4, k)).toString();
2654    } else {
2655      k = 16;
2656      y = '2.3283064365386962890625e-10';
2657    }
2658
2659    Ctor.precision += k;
2660
2661    x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));
2662
2663    // Reverse argument reduction
2664    for (var i = k; i--;) {
2665      var cos2x = x.times(x);
2666      x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);
2667    }
2668
2669    Ctor.precision -= k;
2670
2671    return x;
2672  }
2673
2674
2675  /*
2676   * Perform division in the specified base.
2677   */
2678  var divide = (function () {
2679
2680    // Assumes non-zero x and k, and hence non-zero result.
2681    function multiplyInteger(x, k, base) {
2682      var temp,
2683        carry = 0,
2684        i = x.length;
2685
2686      for (x = x.slice(); i--;) {
2687        temp = x[i] * k + carry;
2688        x[i] = temp % base | 0;
2689        carry = temp / base | 0;
2690      }
2691
2692      if (carry) x.unshift(carry);
2693
2694      return x;
2695    }
2696
2697    function compare(a, b, aL, bL) {
2698      var i, r;
2699
2700      if (aL != bL) {
2701        r = aL > bL ? 1 : -1;
2702      } else {
2703        for (i = r = 0; i < aL; i++) {
2704          if (a[i] != b[i]) {
2705            r = a[i] > b[i] ? 1 : -1;
2706            break;
2707          }
2708        }
2709      }
2710
2711      return r;
2712    }
2713
2714    function subtract(a, b, aL, base) {
2715      var i = 0;
2716
2717      // Subtract b from a.
2718      for (; aL--;) {
2719        a[aL] -= i;
2720        i = a[aL] < b[aL] ? 1 : 0;
2721        a[aL] = i * base + a[aL] - b[aL];
2722      }
2723
2724      // Remove leading zeros.
2725      for (; !a[0] && a.length > 1;) a.shift();
2726    }
2727
2728    return function (x, y, pr, rm, dp, base) {
2729      var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,
2730        yL, yz,
2731        Ctor = x.constructor,
2732        sign = x.s == y.s ? 1 : -1,
2733        xd = x.d,
2734        yd = y.d;
2735
2736      // Either NaN, Infinity or 0?
2737      if (!xd || !xd[0] || !yd || !yd[0]) {
2738
2739        return new Ctor(// Return NaN if either NaN, or both Infinity or 0.
2740          !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :
2741
2742          // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.
2743          xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);
2744      }
2745
2746      if (base) {
2747        logBase = 1;
2748        e = x.e - y.e;
2749      } else {
2750        base = BASE;
2751        logBase = LOG_BASE;
2752        e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);
2753      }
2754
2755      yL = yd.length;
2756      xL = xd.length;
2757      q = new Ctor(sign);
2758      qd = q.d = [];
2759
2760      // Result exponent may be one less than e.
2761      // The digit array of a Decimal from toStringBinary may have trailing zeros.
2762      for (i = 0; yd[i] == (xd[i] || 0); i++);
2763
2764      if (yd[i] > (xd[i] || 0)) e--;
2765
2766      if (pr == null) {
2767        sd = pr = Ctor.precision;
2768        rm = Ctor.rounding;
2769      } else if (dp) {
2770        sd = pr + (x.e - y.e) + 1;
2771      } else {
2772        sd = pr;
2773      }
2774
2775      if (sd < 0) {
2776        qd.push(1);
2777        more = true;
2778      } else {
2779
2780        // Convert precision in number of base 10 digits to base 1e7 digits.
2781        sd = sd / logBase + 2 | 0;
2782        i = 0;
2783
2784        // divisor < 1e7
2785        if (yL == 1) {
2786          k = 0;
2787          yd = yd[0];
2788          sd++;
2789
2790          // k is the carry.
2791          for (; (i < xL || k) && sd--; i++) {
2792            t = k * base + (xd[i] || 0);
2793            qd[i] = t / yd | 0;
2794            k = t % yd | 0;
2795          }
2796
2797          more = k || i < xL;
2798
2799        // divisor >= 1e7
2800        } else {
2801
2802          // Normalise xd and yd so highest order digit of yd is >= base/2
2803          k = base / (yd[0] + 1) | 0;
2804
2805          if (k > 1) {
2806            yd = multiplyInteger(yd, k, base);
2807            xd = multiplyInteger(xd, k, base);
2808            yL = yd.length;
2809            xL = xd.length;
2810          }
2811
2812          xi = yL;
2813          rem = xd.slice(0, yL);
2814          remL = rem.length;
2815
2816          // Add zeros to make remainder as long as divisor.
2817          for (; remL < yL;) rem[remL++] = 0;
2818
2819          yz = yd.slice();
2820          yz.unshift(0);
2821          yd0 = yd[0];
2822
2823          if (yd[1] >= base / 2) ++yd0;
2824
2825          do {
2826            k = 0;
2827
2828            // Compare divisor and remainder.
2829            cmp = compare(yd, rem, yL, remL);
2830
2831            // If divisor < remainder.
2832            if (cmp < 0) {
2833
2834              // Calculate trial digit, k.
2835              rem0 = rem[0];
2836              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
2837
2838              // k will be how many times the divisor goes into the current remainder.
2839              k = rem0 / yd0 | 0;
2840
2841              //  Algorithm:
2842              //  1. product = divisor * trial digit (k)
2843              //  2. if product > remainder: product -= divisor, k--
2844              //  3. remainder -= product
2845              //  4. if product was < remainder at 2:
2846              //    5. compare new remainder and divisor
2847              //    6. If remainder > divisor: remainder -= divisor, k++
2848
2849              if (k > 1) {
2850                if (k >= base) k = base - 1;
2851
2852                // product = divisor * trial digit.
2853                prod = multiplyInteger(yd, k, base);
2854                prodL = prod.length;
2855                remL = rem.length;
2856
2857                // Compare product and remainder.
2858                cmp = compare(prod, rem, prodL, remL);
2859
2860                // product > remainder.
2861                if (cmp == 1) {
2862                  k--;
2863
2864                  // Subtract divisor from product.
2865                  subtract(prod, yL < prodL ? yz : yd, prodL, base);
2866                }
2867              } else {
2868
2869                // cmp is -1.
2870                // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1
2871                // to avoid it. If k is 1 there is a need to compare yd and rem again below.
2872                if (k == 0) cmp = k = 1;
2873                prod = yd.slice();
2874              }
2875
2876              prodL = prod.length;
2877              if (prodL < remL) prod.unshift(0);
2878
2879              // Subtract product from remainder.
2880              subtract(rem, prod, remL, base);
2881
2882              // If product was < previous remainder.
2883              if (cmp == -1) {
2884                remL = rem.length;
2885
2886                // Compare divisor and new remainder.
2887                cmp = compare(yd, rem, yL, remL);
2888
2889                // If divisor < new remainder, subtract divisor from remainder.
2890                if (cmp < 1) {
2891                  k++;
2892
2893                  // Subtract divisor from remainder.
2894                  subtract(rem, yL < remL ? yz : yd, remL, base);
2895                }
2896              }
2897
2898              remL = rem.length;
2899            } else if (cmp === 0) {
2900              k++;
2901              rem = [0];
2902            }    // if cmp === 1, k will be 0
2903
2904            // Add the next digit, k, to the result array.
2905            qd[i++] = k;
2906
2907            // Update the remainder.
2908            if (cmp && rem[0]) {
2909              rem[remL++] = xd[xi] || 0;
2910            } else {
2911              rem = [xd[xi]];
2912              remL = 1;
2913            }
2914
2915          } while ((xi++ < xL || rem[0] !== void 0) && sd--);
2916
2917          more = rem[0] !== void 0;
2918        }
2919
2920        // Leading zero?
2921        if (!qd[0]) qd.shift();
2922      }
2923
2924      // logBase is 1 when divide is being used for base conversion.
2925      if (logBase == 1) {
2926        q.e = e;
2927        inexact = more;
2928      } else {
2929
2930        // To calculate q.e, first get the number of digits of qd[0].
2931        for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;
2932        q.e = i + e * logBase - 1;
2933
2934        finalise(q, dp ? pr + q.e + 1 : pr, rm, more);
2935      }
2936
2937      return q;
2938    };
2939  })();
2940
2941
2942  /*
2943   * Round `x` to `sd` significant digits using rounding mode `rm`.
2944   * Check for over/under-flow.
2945   */
2946   function finalise(x, sd, rm, isTruncated) {
2947    var digits, i, j, k, rd, roundUp, w, xd, xdi,
2948      Ctor = x.constructor;
2949
2950    // Don't round if sd is null or undefined.
2951    out: if (sd != null) {
2952      xd = x.d;
2953
2954      // Infinity/NaN.
2955      if (!xd) return x;
2956
2957      // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.
2958      // w: the word of xd containing rd, a base 1e7 number.
2959      // xdi: the index of w within xd.
2960      // digits: the number of digits of w.
2961      // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if
2962      // they had leading zeros)
2963      // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).
2964
2965      // Get the length of the first word of the digits array xd.
2966      for (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;
2967      i = sd - digits;
2968
2969      // Is the rounding digit in the first word of xd?
2970      if (i < 0) {
2971        i += LOG_BASE;
2972        j = sd;
2973        w = xd[xdi = 0];
2974
2975        // Get the rounding digit at index j of w.
2976        rd = w / mathpow(10, digits - j - 1) % 10 | 0;
2977      } else {
2978        xdi = Math.ceil((i + 1) / LOG_BASE);
2979        k = xd.length;
2980        if (xdi >= k) {
2981          if (isTruncated) {
2982
2983            // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.
2984            for (; k++ <= xdi;) xd.push(0);
2985            w = rd = 0;
2986            digits = 1;
2987            i %= LOG_BASE;
2988            j = i - LOG_BASE + 1;
2989          } else {
2990            break out;
2991          }
2992        } else {
2993          w = k = xd[xdi];
2994
2995          // Get the number of digits of w.
2996          for (digits = 1; k >= 10; k /= 10) digits++;
2997
2998          // Get the index of rd within w.
2999          i %= LOG_BASE;
3000
3001          // Get the index of rd within w, adjusted for leading zeros.
3002          // The number of leading zeros of w is given by LOG_BASE - digits.
3003          j = i - LOG_BASE + digits;
3004
3005          // Get the rounding digit at index j of w.
3006          rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;
3007        }
3008      }
3009
3010      // Are there any non-zero digits after the rounding digit?
3011      isTruncated = isTruncated || sd < 0 ||
3012        xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));
3013
3014      // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right
3015      // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression
3016      // will give 714.
3017
3018      roundUp = rm < 4
3019        ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
3020        : rd > 5 || rd == 5 && (rm == 4 || isTruncated || rm == 6 &&
3021
3022          // Check whether the digit to the left of the rounding digit is odd.
3023          ((i > 0 ? j > 0 ? w / mathpow(10, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||
3024            rm == (x.s < 0 ? 8 : 7));
3025
3026      if (sd < 1 || !xd[0]) {
3027        xd.length = 0;
3028        if (roundUp) {
3029
3030          // Convert sd to decimal places.
3031          sd -= x.e + 1;
3032
3033          // 1, 0.1, 0.01, 0.001, 0.0001 etc.
3034          xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);
3035          x.e = -sd || 0;
3036        } else {
3037
3038          // Zero.
3039          xd[0] = x.e = 0;
3040        }
3041
3042        return x;
3043      }
3044
3045      // Remove excess digits.
3046      if (i == 0) {
3047        xd.length = xdi;
3048        k = 1;
3049        xdi--;
3050      } else {
3051        xd.length = xdi + 1;
3052        k = mathpow(10, LOG_BASE - i);
3053
3054        // E.g. 56700 becomes 56000 if 7 is the rounding digit.
3055        // j > 0 means i > number of leading zeros of w.
3056        xd[xdi] = j > 0 ? (w / mathpow(10, digits - j) % mathpow(10, j) | 0) * k : 0;
3057      }
3058
3059      if (roundUp) {
3060        for (;;) {
3061
3062          // Is the digit to be rounded up in the first word of xd?
3063          if (xdi == 0) {
3064
3065            // i will be the length of xd[0] before k is added.
3066            for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;
3067            j = xd[0] += k;
3068            for (k = 1; j >= 10; j /= 10) k++;
3069
3070            // if i != k the length has increased.
3071            if (i != k) {
3072              x.e++;
3073              if (xd[0] == BASE) xd[0] = 1;
3074            }
3075
3076            break;
3077          } else {
3078            xd[xdi] += k;
3079            if (xd[xdi] != BASE) break;
3080            xd[xdi--] = 0;
3081            k = 1;
3082          }
3083        }
3084      }
3085
3086      // Remove trailing zeros.
3087      for (i = xd.length; xd[--i] === 0;) xd.pop();
3088    }
3089
3090    if (external) {
3091
3092      // Overflow?
3093      if (x.e > Ctor.maxE) {
3094
3095        // Infinity.
3096        x.d = null;
3097        x.e = NaN;
3098
3099      // Underflow?
3100      } else if (x.e < Ctor.minE) {
3101
3102        // Zero.
3103        x.e = 0;
3104        x.d = [0];
3105        // Ctor.underflow = true;
3106      } // else Ctor.underflow = false;