precision-math/lib/index.js

Allows for precise decimal operations without the use of floats.

'use strict';

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

module.exports.add = _add;
module.exports.sum = _add;

module.exports.subtract = _subtract;
module.exports.sub = _subtract;
module.exports.minus = _subtract;
module.exports.difference = _subtract;
module.exports.diff = _subtract;

module.exports.multiply = _multiply;
module.exports.mult = _multiply;
module.exports.product = _multiply;
module.exports.prod = _multiply;

/**
 *
 */
function _add() {
  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  var operational = args.map(function (arg) {
    return _decimalToOperational(arg);
  });
  var maxMagnitude = _getMaxMagnitude.apply(undefined, _toConsumableArray(operational));
  var normalized = _normalize.apply(undefined, [{ maxMagnitude: maxMagnitude }].concat(_toConsumableArray(operational)));

  var result = normalized.reduce(function (result, arg) {
    return !result ? arg : _extends({}, arg, { num: result.num + arg.num });
  });

  return _operationalToDecimal(result);
}

/**
 *
 */
function _subtract() {
  for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    args[_key2] = arguments[_key2];
  }

  var operational = args.map(function (arg) {
    return _decimalToOperational(arg);
  });
  var maxMagnitude = _getMaxMagnitude.apply(undefined, _toConsumableArray(operational));
  var normalized = _normalize.apply(undefined, [{ maxMagnitude: maxMagnitude }].concat(_toConsumableArray(operational)));

  var result = normalized.reduce(function (result, arg) {
    return !result ? arg : _extends({}, arg, { num: result.num - arg.num });
  });

  return _operationalToDecimal(result);
}

/**
 *
 */
function _multiply() {
  for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    args[_key3] = arguments[_key3];
  }

  var operational = args.map(function (arg) {
    return _decimalToOperational(arg);
  });
  var maxMagnitude = _getMaxMagnitude.apply(undefined, _toConsumableArray(operational));
  var normalized = _normalize.apply(undefined, [{ maxMagnitude: maxMagnitude }].concat(_toConsumableArray(operational)));

  var result = normalized.reduce(function (result, arg) {
    if (!result) return agg;

    return _extends({}, arg, {
      num: result.num * arg.num,
      magnitude: result.magnitude + arg.magnitude
    });
  });

  var asDecimal = _operationalToDecimal(result);
  return _trimTrailingZeroesTo(asDecimal, Number(maxMagnitude));
}

/**
 *
 */
function _normalize(_ref) {
  var maxMagnitude = _ref.maxMagnitude;

  for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
    args[_key4 - 1] = arguments[_key4];
  }

  return args.map(function (arg) {
    return _extends({}, arg, {
      magnitude: maxMagnitude,
      num: arg.num * Math.pow(BigInt(10), maxMagnitude - arg.magnitude)
    });
  });
}

/**
 *
 */
function _getMaxMagnitude() {
  for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
    args[_key5] = arguments[_key5];
  }

  return args.reduce(function (max, _ref2) {
    var magnitude = _ref2.magnitude;

    return magnitude > max ? magnitude : max;
  }, BigInt(0));
}

/**
 *
 */
function _decimalToOperational(number) {
  var _String$split = String(number).split('.'),
      _String$split2 = _slicedToArray(_String$split, 2),
      pre = _String$split2[0],
      _String$split2$ = _String$split2[1],
      post = _String$split2$ === undefined ? '' : _String$split2$;

  return {
    num: BigInt(pre + post),
    magnitude: BigInt(post.length)
  };
}

/**
 *
 */
function _operationalToDecimal(_ref3) {
  var num = _ref3.num,
      magnitude = _ref3.magnitude;

  var asString = String(num);
  if (!magnitude) return asString;

  magnitude = Number(magnitude);
  var decimalPointPosition = asString.length - magnitude;

  if (decimalPointPosition > 0) {
    return asString.slice(0, decimalPointPosition) + '.' + asString.slice(decimalPointPosition);
  }

  var pre = '0';
  var post = _pad(asString, Math.abs(decimalPointPosition));

  return pre + '.' + post;
}

/**
 *
 */
function _pad(number, amount) {
  for (var i = 0; i < amount; i++) {
    number = '0' + number;
  }
  return number;
}

/**
 *
 */
function _trimTrailingZeroesTo(number, minPostDecimalDigits) {
  var _number$split = number.split('.'),
      _number$split2 = _slicedToArray(_number$split, 2),
      pre = _number$split2[0],
      post = _number$split2[1];

  if (!post.length) return number;

  var toRemove = post.length - minPostDecimalDigits;

  if (toRemove < 0) return number;

  return pre + '.' + post.replace(new RegExp('0{0,' + toRemove + '}$'), '');
}