bluzelle-lib-value/dist/npm/value.js

'use strict';

var _createClass = require('babel-runtime/helpers/create-class')['default'];

var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];

var GlobalBigNumber = require('bignumber.js');

var BigNumber = GlobalBigNumber.another({
  ROUNDING_MODE: GlobalBigNumber.ROUND_HALF_UP,
  DECIMAL_PLACES: 40
});

var assert = require('assert');

var Value = (function () {
  function Value(value) {
    _classCallCheck(this, Value);

    if (this.constructor === 'Value') {
      throw new Error('Cannot instantiate Value directly, it is an abstract base class');
    }
    this._value = new BigNumber(value);
  }

  _createClass(Value, [{
    key: 'abs',
    value: function abs() {
      var result = this._value.abs();
      return this._canonicalize(result);
    }
  }, {
    key: 'add',
    value: function add(addend) {
      assert(this.constructor === addend.constructor);
      var result = this._value.plus(addend._value);
      return this._canonicalize(result);
    }
  }, {
    key: 'subtract',
    value: function subtract(subtrahend) {
      assert(this.constructor === subtrahend.constructor);
      var result = this._value.minus(subtrahend._value);
      return this._canonicalize(result);
    }
  }, {
    key: 'multiply',
    value: function multiply(multiplicand) {
      var result = this._value.times(multiplicand._value);
      return this._canonicalize(result);
    }
  }, {
    key: 'divide',
    value: function divide(divisor) {
      if (divisor.isZero()) {
        throw new Error('divide by zero');
      }
      var result = this._value.dividedBy(divisor._value);
      return this._canonicalize(result);
    }
  }, {
    key: 'invert',
    value: function invert() {
      var result = new BigNumber(this._value).toPower(-1);
      return this._canonicalize(result);
    }
  }, {
    key: 'round',
    value: function round(decimalPlaces, roundingMode) {
      var result = this._value.round(decimalPlaces, roundingMode);
      return this._canonicalize(result);
    }
  }, {
    key: 'toFixed',
    value: function toFixed(decimalPlaces, roundingMode) {
      return this._value.toFixed(decimalPlaces, roundingMode);
    }
  }, {
    key: 'getExponent',
    value: function getExponent() {
      return this._value.e;
    }
  }, {
    key: 'isNaN',
    value: function isNaN() {
      return this._value.isNaN();
    }
  }, {
    key: 'isZero',
    value: function isZero() {
      return this._value.isZero();
    }
  }, {
    key: 'isNegative',
    value: function isNegative() {
      return this._value.isNegative();
    }
  }, {
    key: 'toString',
    value: function toString() {
      return this._value.toString();
    }
  }, {
    key: 'greaterThan',
    value: function greaterThan(comparator) {
      assert(this.constructor === comparator.constructor);
      return this._value.greaterThan(comparator._value);
    }
  }, {
    key: 'lessThan',
    value: function lessThan(comparator) {
      assert(this.constructor === comparator.constructor);
      return this._value.lessThan(comparator._value);
    }
  }, {
    key: 'comparedTo',
    value: function comparedTo(comparator) {
      assert(this.constructor === comparator.constructor);
      return this._value.comparedTo(comparator._value);
    }
  }], [{
    key: 'getBNRoundDown',
    value: function getBNRoundDown() {
      return BigNumber.ROUND_DOWN;
    }
  }]);

  return Value;
})();

exports.Value = Value;