You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					115 lines
				
				2.7 KiB
			
		
		
			
		
	
	
					115 lines
				
				2.7 KiB
			| 
								 
											3 years ago
										 
									 | 
							
								'use strict';
							 | 
						||
| 
								 | 
							
								var $export = require('./_export');
							 | 
						||
| 
								 | 
							
								var toInteger = require('./_to-integer');
							 | 
						||
| 
								 | 
							
								var aNumberValue = require('./_a-number-value');
							 | 
						||
| 
								 | 
							
								var repeat = require('./_string-repeat');
							 | 
						||
| 
								 | 
							
								var $toFixed = 1.0.toFixed;
							 | 
						||
| 
								 | 
							
								var floor = Math.floor;
							 | 
						||
| 
								 | 
							
								var data = [0, 0, 0, 0, 0, 0];
							 | 
						||
| 
								 | 
							
								var ERROR = 'Number.toFixed: incorrect invocation!';
							 | 
						||
| 
								 | 
							
								var ZERO = '0';
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								var multiply = function (n, c) {
							 | 
						||
| 
								 | 
							
								  var i = -1;
							 | 
						||
| 
								 | 
							
								  var c2 = c;
							 | 
						||
| 
								 | 
							
								  while (++i < 6) {
							 | 
						||
| 
								 | 
							
								    c2 += n * data[i];
							 | 
						||
| 
								 | 
							
								    data[i] = c2 % 1e7;
							 | 
						||
| 
								 | 
							
								    c2 = floor(c2 / 1e7);
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								var divide = function (n) {
							 | 
						||
| 
								 | 
							
								  var i = 6;
							 | 
						||
| 
								 | 
							
								  var c = 0;
							 | 
						||
| 
								 | 
							
								  while (--i >= 0) {
							 | 
						||
| 
								 | 
							
								    c += data[i];
							 | 
						||
| 
								 | 
							
								    data[i] = floor(c / n);
							 | 
						||
| 
								 | 
							
								    c = (c % n) * 1e7;
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								var numToString = function () {
							 | 
						||
| 
								 | 
							
								  var i = 6;
							 | 
						||
| 
								 | 
							
								  var s = '';
							 | 
						||
| 
								 | 
							
								  while (--i >= 0) {
							 | 
						||
| 
								 | 
							
								    if (s !== '' || i === 0 || data[i] !== 0) {
							 | 
						||
| 
								 | 
							
								      var t = String(data[i]);
							 | 
						||
| 
								 | 
							
								      s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								  } return s;
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								var pow = function (x, n, acc) {
							 | 
						||
| 
								 | 
							
								  return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								var log = function (x) {
							 | 
						||
| 
								 | 
							
								  var n = 0;
							 | 
						||
| 
								 | 
							
								  var x2 = x;
							 | 
						||
| 
								 | 
							
								  while (x2 >= 4096) {
							 | 
						||
| 
								 | 
							
								    n += 12;
							 | 
						||
| 
								 | 
							
								    x2 /= 4096;
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								  while (x2 >= 2) {
							 | 
						||
| 
								 | 
							
								    n += 1;
							 | 
						||
| 
								 | 
							
								    x2 /= 2;
							 | 
						||
| 
								 | 
							
								  } return n;
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								$export($export.P + $export.F * (!!$toFixed && (
							 | 
						||
| 
								 | 
							
								  0.00008.toFixed(3) !== '0.000' ||
							 | 
						||
| 
								 | 
							
								  0.9.toFixed(0) !== '1' ||
							 | 
						||
| 
								 | 
							
								  1.255.toFixed(2) !== '1.25' ||
							 | 
						||
| 
								 | 
							
								  1000000000000000128.0.toFixed(0) !== '1000000000000000128'
							 | 
						||
| 
								 | 
							
								) || !require('./_fails')(function () {
							 | 
						||
| 
								 | 
							
								  // V8 ~ Android 4.3-
							 | 
						||
| 
								 | 
							
								  $toFixed.call({});
							 | 
						||
| 
								 | 
							
								})), 'Number', {
							 | 
						||
| 
								 | 
							
								  toFixed: function toFixed(fractionDigits) {
							 | 
						||
| 
								 | 
							
								    var x = aNumberValue(this, ERROR);
							 | 
						||
| 
								 | 
							
								    var f = toInteger(fractionDigits);
							 | 
						||
| 
								 | 
							
								    var s = '';
							 | 
						||
| 
								 | 
							
								    var m = ZERO;
							 | 
						||
| 
								 | 
							
								    var e, z, j, k;
							 | 
						||
| 
								 | 
							
								    if (f < 0 || f > 20) throw RangeError(ERROR);
							 | 
						||
| 
								 | 
							
								    // eslint-disable-next-line no-self-compare
							 | 
						||
| 
								 | 
							
								    if (x != x) return 'NaN';
							 | 
						||
| 
								 | 
							
								    if (x <= -1e21 || x >= 1e21) return String(x);
							 | 
						||
| 
								 | 
							
								    if (x < 0) {
							 | 
						||
| 
								 | 
							
								      s = '-';
							 | 
						||
| 
								 | 
							
								      x = -x;
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								    if (x > 1e-21) {
							 | 
						||
| 
								 | 
							
								      e = log(x * pow(2, 69, 1)) - 69;
							 | 
						||
| 
								 | 
							
								      z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);
							 | 
						||
| 
								 | 
							
								      z *= 0x10000000000000;
							 | 
						||
| 
								 | 
							
								      e = 52 - e;
							 | 
						||
| 
								 | 
							
								      if (e > 0) {
							 | 
						||
| 
								 | 
							
								        multiply(0, z);
							 | 
						||
| 
								 | 
							
								        j = f;
							 | 
						||
| 
								 | 
							
								        while (j >= 7) {
							 | 
						||
| 
								 | 
							
								          multiply(1e7, 0);
							 | 
						||
| 
								 | 
							
								          j -= 7;
							 | 
						||
| 
								 | 
							
								        }
							 | 
						||
| 
								 | 
							
								        multiply(pow(10, j, 1), 0);
							 | 
						||
| 
								 | 
							
								        j = e - 1;
							 | 
						||
| 
								 | 
							
								        while (j >= 23) {
							 | 
						||
| 
								 | 
							
								          divide(1 << 23);
							 | 
						||
| 
								 | 
							
								          j -= 23;
							 | 
						||
| 
								 | 
							
								        }
							 | 
						||
| 
								 | 
							
								        divide(1 << j);
							 | 
						||
| 
								 | 
							
								        multiply(1, 1);
							 | 
						||
| 
								 | 
							
								        divide(2);
							 | 
						||
| 
								 | 
							
								        m = numToString();
							 | 
						||
| 
								 | 
							
								      } else {
							 | 
						||
| 
								 | 
							
								        multiply(0, z);
							 | 
						||
| 
								 | 
							
								        multiply(1 << -e, 0);
							 | 
						||
| 
								 | 
							
								        m = numToString() + repeat.call(ZERO, f);
							 | 
						||
| 
								 | 
							
								      }
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								    if (f > 0) {
							 | 
						||
| 
								 | 
							
								      k = m.length;
							 | 
						||
| 
								 | 
							
								      m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));
							 | 
						||
| 
								 | 
							
								    } else {
							 | 
						||
| 
								 | 
							
								      m = s + m;
							 | 
						||
| 
								 | 
							
								    } return m;
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								});
							 |