powiaina_num.js 0.1.12 → 0.2.0-alpha.2

package/dist/PowiainaNum.cjs.js

@@ -0,0 +1,994 @@
+'use strict';
+
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+var MSI = 9007199254740991;
+var MSI_LOG10 = 15.954589770191003;
+var MSI_REC = 1.1102230246251568e-16;
+var LONG_STRING_MIN_LENGTH = 17;
+function newOperator(r) {
+  var a = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var e = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var m = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  return {
+    repeat: r,
+    arrow: a,
+    expans: e,
+    megota: m,
+    valuereplaced: a == Infinity ? 0 : e == Infinity ? 1 : -1
+  };
+}
+function compareTuples() {
+  for (var _len = arguments.length, tuples = new Array(_len), _key = 0; _key < _len; _key++) {
+    tuples[_key] = arguments[_key];
+  }
+  for (var i = 0; i < Math.min(tuples[0].length, tuples[1].length); i++) {
+    var a = tuples[0][i];
+    var b = tuples[1][i];
+    if (a < b) return -1;
+    if (a > b) return 1;
+  }
+  return 0;
+}
+function log10LongString(str) {
+  return Math.log10(Number(str.substring(0, LONG_STRING_MIN_LENGTH))) + (str.length - LONG_STRING_MIN_LENGTH);
+}
+var PowiainaNum = /*#__PURE__*/function () {
+  function PowiainaNum(arg1) {
+    _classCallCheck(this, PowiainaNum);
+    this.array = [{
+      arrow: 0,
+      expans: 1,
+      megota: 1,
+      repeat: NaN
+    }];
+    this.small = false;
+    this.sign = 0;
+    this.layer = 0;
+    if (typeof arg1 == "undefined") ; else if (typeof arg1 == "number") {
+      var obj = PowiainaNum.fromNumber(arg1);
+      this.resetFromObject(obj);
+    } else if (_typeof(arg1) == "object") {
+      var _obj = PowiainaNum.fromObject(arg1);
+      this.resetFromObject(_obj);
+    } else if (typeof arg1 == "string") {
+      var _obj2 = PowiainaNum.fromString(arg1);
+      this.resetFromObject(_obj2);
+    } else ;
+  }
+  /**
+   * Addition
+   * @returns the sum of `this` and `other`
+   */
+  return _createClass(PowiainaNum, [{
+    key: "add",
+    value: function add(other) {
+      var x = this.clone();
+      var y = new PowiainaNum(other);
+      // inf + -inf = nan
+      if (x.eq(PowiainaNum.POSITIVE_INFINITY) && y.eq(PowiainaNum.NEGATIVE_INFINITY) || x.eq(PowiainaNum.NEGATIVE_INFINITY) && y.eq(PowiainaNum.POSITIVE_INFINITY)) return PowiainaNum.NaN.clone();
+      // inf & nan check
+      if (!x.isFinite()) return x.clone();
+      if (!y.isFinite()) return y.clone();
+      // if x or y = 0, return other.
+      if (x.isZero()) return y.clone();
+      if (y.isZero()) return x.clone();
+      // x+ -x = 0
+      if (x.sign == -y.sign && function () {
+        var a = x.abs();
+        var b = y.abs();
+        return a.eq(b);
+      }()) return PowiainaNum.ZERO.clone();
+      // calculate anything > e9e15 or <e-9e15, take absval bigger.
+      if (x.abs().lt(PowiainaNum.E_MSI_REC) || x.abs().gt(PowiainaNum.E_MSI) || y.abs().lt(PowiainaNum.E_MSI_REC) || y.abs().gt(PowiainaNum.E_MSI)) {
+        return x.maxabs(y);
+      }
+      if (x.sign == -1) {
+        return x.neg().add(y.neg()).neg();
+      }
+      // if ((x.sign==1&&y.sign==-1&&x.lt(y.abs()))  ) return y.neg().add(x.neg()).neg();
+      var a, b; //a=bigger, b=smaller
+      if (x.cmpabs(y) > 0) {
+        a = x;
+        b = y;
+      } else {
+        b = x;
+        a = y;
+      }
+      var mult = 1;
+      if (!a.small && !b.small && !a.getOperator(1) && !b.getOperator(1) && a.sign == b.sign) {
+        return new PowiainaNum((a.getOperator(0) + b.getOperator(0)) * a.sign);
+      }
+      var alog10 = (a.small ? -1 : 1) * (a.getOperator(1) ? a.getOperator(0) : Math.log10(a.getOperator(0)));
+      var blog10 = (b.small ? -1 : 1) * (b.getOperator(1) ? b.getOperator(0) : Math.log10(b.getOperator(0)));
+      if (alog10 - blog10 > MSI_LOG10) return a;
+      var offset = -Math.floor(alog10); //a number can make a+off in [0,1)
+      var r,
+        l = 0,
+        t;
+      t = a.sign * Math.pow(10, alog10 + offset) + b.sign * Math.pow(10, blog10 + offset);
+      if (t > 0) l = Math.log10(t) - offset;
+      if (t < 0) {
+        l = Math.log10(-t) - offset;
+        mult *= -1;
+      }
+      if (t == 0) throw Error("Encounter a calculate error");
+      r = new PowiainaNum();
+      r.sign = 1;
+      if (l > MSI_LOG10 || l < -MSI_LOG10) {
+        r.setOperator(1, 1);
+        r.setOperator(Math.log10(Math.abs(l)), 1);
+      } else {
+        r.setOperator(Math.pow(10, Math.abs(l)), 0);
+      }
+      r.small = l < 0 ? true : false;
+      r.sign *= mult;
+      return r;
+    }
+  }, {
+    key: "sub",
+    value: function sub(a) {
+      return this.add(new PowiainaNum(a).neg());
+    }
+  }, {
+    key: "mul",
+    value: function mul(other) {
+      var x = this.clone();
+      var y = new PowiainaNum(other);
+      // inf * -inf = -inf
+      if (x.eq(PowiainaNum.POSITIVE_INFINITY) && y.eq(PowiainaNum.NEGATIVE_INFINITY) || y.eq(PowiainaNum.POSITIVE_INFINITY) && x.eq(PowiainaNum.NEGATIVE_INFINITY)) return PowiainaNum.NEGATIVE_INFINITY.clone();
+      if (x.isInfinite() && y.eq(PowiainaNum.ZERO) && y.isInfinite() && x.eq(PowiainaNum.ZERO)) return PowiainaNum.NaN.clone();
+      if (x.eq(PowiainaNum.NEGATIVE_INFINITY) && y.eq(PowiainaNum.NEGATIVE_INFINITY)) return PowiainaNum.POSITIVE_INFINITY.clone();
+      // inf & nan check
+      if (!x.isFinite()) return x.clone();
+      if (!y.isFinite()) return y.clone();
+      if (x.isZero() || y.isZero()) return PowiainaNum.ZERO.clone();
+      // x* x^-1 = 0
+      /* if (x.small==1-y.small&&(function(){
+        let a = x.abs();
+        let b = y.abs();
+        return a.eq(b)
+      })()) return (function () {
+        let a = new PowiainaNum(1);
+        a.sign = x.sign*y.sign as -1|0| 1;
+        return a;
+      })(); */
+      var r;
+      r = x.abs().log10().add(y.abs().log10()).pow10();
+      r.sign = x.sign * y.sign;
+      return r;
+    }
+  }, {
+    key: "div",
+    value: function div(other) {
+      var x = new PowiainaNum(other).rec();
+      return this.mul(x);
+    }
+  }, {
+    key: "pow10",
+    value: function pow10() {
+      var r = this.clone();
+      // inf & nan check
+      if (!this.isFinite()) return this.clone();
+      if (r.lt(0)) {
+        // 10^(-x) = 1/(10^x)
+        r.sign *= -1;
+        return r.pow10().rec();
+      }
+      if (r.small) {
+        if (r.lt(PowiainaNum.MSI_REC)) return PowiainaNum.ONE;
+        return new PowiainaNum(Math.pow(10, Math.pow(r.getOperator(0), -1)));
+      }
+      r.setOperator(r.getOperator(1) + 1, 1);
+      r.normalize();
+      return r;
+    }
+  }, {
+    key: "pow",
+    value: function pow(x) {
+      var other = new PowiainaNum(x);
+      if (!other.isFinite()) return other.clone();
+      if (!this.isFinite()) return this.clone();
+      if (this.eq(10)) return other.pow10();
+      if (this.lt(0)) {
+        if (!other.isInt()) return PowiainaNum.NaN.clone();
+        var r = this.abs().pow(other);
+        r.sign = function () {
+          var a = other.mod(2).round();
+          if (a.eq(0) || a.eq(2)) return 1;
+          return -1;
+        }();
+        return r;
+      }
+      // log10(a^b) = b log10(a)
+      return this.log10().mul(other).pow10();
+    }
+  }, {
+    key: "pow_base",
+    value: function pow_base(x) {
+      var a = new PowiainaNum(x);
+      return a.pow(this);
+    }
+  }, {
+    key: "root",
+    value: function root(x) {
+      var other = new PowiainaNum(x);
+      return this.pow(other.rec());
+    }
+  }, {
+    key: "sqrt",
+    value: function sqrt() {
+      return this.pow(0.5);
+    }
+  }, {
+    key: "cbrt",
+    value: function cbrt() {
+      return this.root(3);
+    }
+  }, {
+    key: "abs",
+    value: function abs() {
+      var obj = this.clone();
+      if (obj.sign < 0) obj.sign *= -1;
+      return obj;
+    }
+  }, {
+    key: "log10",
+    value: function log10() {
+      if (this.lt(0)) return PowiainaNum.NaN.clone();
+      if (this.isZero()) return PowiainaNum.NEGATIVE_INFINITY.clone();
+      if (this.small) {
+        var _x = this.clone();
+        _x.small = !_x.small;
+        return _x.log10().neg();
+      }
+      if (this.getOperator(1) == 0) return new PowiainaNum(Math.log10(this.getOperator(0)));
+      var x = this.clone();
+      x.setOperator(x.getOperator(1) - 1, 1);
+      x.normalize();
+      return x;
+    }
+  }, {
+    key: "log",
+    value: function log(base) {
+      // log_a b = log_x b / log_x a;
+      var other = new PowiainaNum(base);
+      return this.log10().div(other.log10());
+    }
+  }, {
+    key: "mod",
+    value: function mod(x) {
+      var other = new PowiainaNum(x);
+      var division = this.div(other);
+      return division.sub(division.floor()).mul(other);
+    }
+  }, {
+    key: "max",
+    value: function max(x) {
+      var other = new PowiainaNum(x);
+      return this.lt(other) ? other.clone() : this.clone();
+    }
+  }, {
+    key: "min",
+    value: function min(x) {
+      var other = new PowiainaNum(x);
+      return this.gte(other) ? other.clone() : this.clone();
+    }
+  }, {
+    key: "maxabs",
+    value: function maxabs(x) {
+      var other = new PowiainaNum(x).abs();
+      return this.abs().lt(other) ? other.clone() : this.clone();
+    }
+  }, {
+    key: "minabs",
+    value: function minabs(x) {
+      var other = new PowiainaNum(x).abs();
+      return this.abs().gt(other) ? other.clone() : this.clone();
+    }
+  }, {
+    key: "cmpabs",
+    value: function cmpabs(x) {
+      var other = new PowiainaNum(x).abs();
+      return this.abs().cmp(other);
+    }
+  }, {
+    key: "neg",
+    value: function neg() {
+      var a = this.clone();
+      a.sign *= -1;
+      a.normalize();
+      return a;
+    }
+  }, {
+    key: "rec",
+    value: function rec() {
+      var a = this.clone();
+      a.small = !a.small;
+      return a;
+    }
+  }, {
+    key: "floor",
+    value: function floor() {
+      if (this.isInt()) return this.clone();
+      if (this.small) {
+        if (this.sign == 1) return PowiainaNum.ZERO.clone();else return PowiainaNum.ONE.neg().clone();
+      }
+      var r = this.abs();
+      r.setOperator(Math[this.sign == 1 ? "floor" : "ceil"](r.getOperator(0)), 0);
+      return r;
+    }
+  }, {
+    key: "ceil",
+    value: function ceil() {
+      if (this.isInt()) return this.clone();
+      if (this.small) {
+        if (this.sign == 1) return PowiainaNum.ONE.clone();else return PowiainaNum.ZERO.clone();
+      }
+      var r = this.abs();
+      r.setOperator(Math[this.sign == 1 ? "ceil" : "floor"](r.getOperator(0)), 0);
+      r.sign = this.sign;
+      return r;
+    }
+  }, {
+    key: "round",
+    value: function round() {
+      if (this.isInt()) return this.clone();
+      if (this.small) {
+        if (this.sign == 1) {
+          if (this.rec().lte(2)) return PowiainaNum.ONE.clone();else return PowiainaNum.ZERO.clone();
+        } else {
+          if (this.abs().rec().lte(2)) return PowiainaNum.ZERO.clone();else return PowiainaNum.ONE.neg().clone();
+        }
+      }
+      var r = this.abs();
+      r.setOperator(Math.round(r.getOperator(0)), 0);
+      r.sign = this.sign;
+      return r;
+    }
+    /**
+     * @returns if this<other, return -1, if this=other, return 0, if this>other, return 1, if this!<=>, return 2
+     */
+  }, {
+    key: "compare",
+    value: function compare(x) {
+      var other = new PowiainaNum(x);
+      if (this.isNaN() || other.isNaN()) return 2;
+      if (this.sign < other.sign) return -1;
+      if (this.sign > other.sign) return 1;
+      //this.sign = other.sign
+      var allneg = this.sign == -1 && other.sign == -1;
+      if (this.small && !other.small) return -1 * (allneg ? -1 : 1);
+      if (other.small && !this.small) return 1 * (allneg ? -1 : 1);
+      var resultreverse = 1;
+      if (this.small && other.small) resultreverse *= -1;
+      if (allneg) resultreverse *= -1;
+      var result = 0;
+      for (var i = 0; this.array.length - 1 - i >= 0 && other.array.length - 1 - i >= 0; i++) {
+        var op1 = this.array[this.array.length - 1 - i];
+        var op2 = other.array[other.array.length - 1 - i];
+        var cmp = compareTuples([op1.megota, op1.expans, op1.arrow, op1.repeat], [op2.megota, op2.expans, op2.arrow, op2.repeat]);
+        if (cmp == 1) {
+          result = 1;
+          break;
+        } else if (cmp == -1) {
+          result = -1;
+          break;
+        }
+      }
+      return result * resultreverse + 1 - 1;
+    }
+  }, {
+    key: "cmp",
+    value: function cmp(other) {
+      return this.compare(other);
+    }
+  }, {
+    key: "eq",
+    value: function eq(other) {
+      return this.cmp(other) === 0;
+    }
+  }, {
+    key: "neq",
+    value: function neq(other) {
+      return this.cmp(other) !== 0;
+    }
+  }, {
+    key: "lt",
+    value: function lt(other) {
+      return this.cmp(other) === -1;
+    }
+  }, {
+    key: "lte",
+    value: function lte(other) {
+      return this.cmp(other) <= 0;
+    }
+  }, {
+    key: "gt",
+    value: function gt(other) {
+      return this.cmp(other) == 1;
+    }
+  }, {
+    key: "gte",
+    value: function gte(other) {
+      var t = this.cmp(other);
+      return t == 0 || t == 1;
+    }
+  }, {
+    key: "isNaN",
+    value: function (_isNaN) {
+      function isNaN() {
+        return _isNaN.apply(this, arguments);
+      }
+      isNaN.toString = function () {
+        return _isNaN.toString();
+      };
+      return isNaN;
+    }(function () {
+      return isNaN(this.getOperator(0));
+    })
+  }, {
+    key: "isZero",
+    value: function isZero() {
+      return Boolean(this.small && !isFinite(this.getOperator(0)));
+    }
+  }, {
+    key: "isFinite",
+    value: function (_isFinite) {
+      function isFinite() {
+        return _isFinite.apply(this, arguments);
+      }
+      isFinite.toString = function () {
+        return _isFinite.toString();
+      };
+      return isFinite;
+    }(function () {
+      return Boolean(this.small || isFinite(this.getOperator(0))) && !this.isNaN();
+    })
+  }, {
+    key: "isInfinite",
+    value: function isInfinite() {
+      return Boolean(!this.small && !isFinite(this.getOperator(0))) || this.isNaN();
+    }
+  }, {
+    key: "isInt",
+    value: function isInt() {
+      if (this.isZero()) return true;
+      if (!this.small && Number.isInteger(this.getOperator(0))) return true;
+      if (this.abs().gte(Math.pow(2, 52))) return true;
+      return false;
+    }
+    /**
+     * Normalize functions will make this number convert into standard format.(it also change `this`, like [].sort)
+     * @returns normalized number
+     */
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      //TODO: normalize
+      var renormalize = true;
+      var x = this;
+      for (var _i = 0; _i < this.array.length; _i++) {
+        if (this.array[_i].repeat == Infinity) {
+          this.array = [{
+            arrow: 0,
+            expans: 1,
+            megota: 1,
+            repeat: Infinity
+          }];
+          this.layer = 0;
+          return this;
+        }
+      }
+      for (var i = 1; i < x.array.length; ++i) {
+        var e = x.array[i];
+        if (e.arrow === null || e.arrow === undefined) {
+          e.arrow = 0;
+        }
+        if (e.expans === null || e.expans === undefined) {
+          e.expans = 1;
+        }
+        if (e.megota === null || e.megota === undefined) {
+          e.megota = 1;
+        }
+        if (isNaN(e.arrow) || isNaN(e.repeat) || isNaN(e.expans) || isNaN(e.megota)) {
+          x.array = [newOperator(NaN, 0, 1, 1)];
+          return x;
+        }
+        if (!isFinite(e.repeat) || !isFinite(e.megota)) {
+          x.array = [newOperator(Infinity, 0, 1, 1)];
+          return x;
+        }
+        if (!Number.isInteger(e.arrow)) e.arrow = Math.floor(e.arrow);
+        if (!Number.isInteger(e.repeat)) e.repeat = Math.floor(e.repeat);
+        if (!Number.isInteger(e.expans)) e.expans = Math.floor(e.expans);
+        if (!Number.isInteger(e.megota)) e.megota = Math.floor(e.megota);
+      }
+      do {
+        renormalize = false;
+        this.array.sort(function (a, b) {
+          return compareTuples([a.megota, a.expans, a.arrow], [b.megota, b.expans, b.arrow]);
+        });
+        for (i = 1; i < x.array.length; ++i) {
+          // check 0 repeat count
+          if (x.array[i].arrow !== 0 && (x.array[i].repeat === 0 || x.array[i].repeat === null || x.array[i].repeat === undefined)) {
+            x.array.splice(i, 1);
+            --i;
+            continue;
+          }
+          // check arrow 0 and brace count >=2
+          if (x.array[i].arrow == 0 && x.array[i].expans >= 2) {
+            x.array[i].arrow = Infinity;
+            x.array[i].valuereplaced = 0;
+            x.array[i].expans = x.array[i].expans - 1;
+          }
+        }
+        for (var _i2 = 1; _i2 < this.array.length; _i2++) {
+          if (this.array[_i2].repeat == 0) {
+            this.array.splice(_i2, 1);
+            _i2--;
+          }
+        }
+        if (!x.array.length) {
+          x.small = !x.small;
+          x.array = [newOperator(Infinity)]; // if no array set zero
+        }
+        if (x.array.length > PowiainaNum.maxOps) x.array.splice(1, x.array.length - PowiainaNum.maxOps); // max operators check
+        if (this.getOperator(1) >= 1 && this.getOperator(0) < MSI_LOG10) {
+          console.log(this.array);
+          this.setOperator(this.getOperator(1) - 1, 1);
+          this.setOperator(Math.pow(10, this.getOperator(0)), 0);
+          renormalize = true;
+        }
+        if (this.getOperator(0) > MSI) {
+          this.setOperator(this.getOperator(1) + 1, 1);
+          this.setOperator(Math.log10(this.getOperator(0)), 0);
+          renormalize = true;
+        }
+        if (this.array.length == 1 && this.array[0].repeat < 1) {
+          this.array[0].repeat = 1 / this.array[0].repeat;
+          this.small = !this.small;
+          renormalize = true;
+        }
+        while (x.array.length >= 2 && x.array[0].repeat == 1 && x.array[1].repeat) {
+          // [1, [R=1, A=sth, E=sth, M=sth]]
+          if (x.array[1].repeat > 1) {
+            x.array[1].repeat--;
+          } else {
+            x.array.splice(1, 1);
+          }
+          x.array[0].repeat = 10;
+          renormalize = true;
+        }
+        if (x.array.length >= 2 && x.array[0].repeat < MSI && x.array[1].arrow >= 2 && x.array[1].repeat == 1) {
+          // [1e9, [R=1, A=2, sth, sth]]
+          x.array.splice(1, 1, newOperator(x.array[0].repeat, x.array[1].arrow - 1, x.array[1].expans, x.array[1].megota));
+          x.array[0].repeat = 10;
+          renormalize = true;
+        }
+        for (i = 1; i < x.array.length - 1; ++i) {
+          if (x.array[i].arrow == x.array[i + 1].arrow && x.array[i].expans == x.array[i + 1].expans && x.array[i].megota == x.array[i + 1].megota) {
+            // same array's merge
+            x.array[i].repeat += x.array[i + 1].repeat;
+            x.array.splice(i + 1, 1);
+            --i;
+            renormalize = true;
+          }
+        }
+      } while (renormalize);
+      return this;
+    }
+    /**
+     * @returns number will return the index of the operator in array. return as x.5 if it's between the xth and x+1th operators.
+     */
+  }, {
+    key: "getOperatorIndex",
+    value: function getOperatorIndex(arrow) {
+      var expans = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var megota = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      for (var i = 0; i < this.array.length; i++) {
+        var cmp = compareTuples([this.array[i].megota, this.array[i].expans, this.array[i].arrow], [megota, expans, arrow]);
+        if (cmp == 0) return i; // I find it was [xx,xxx,*xxx*,xxx]!
+        if (cmp == 1) return i - 0.5; // It's between [xx, xx,xx*,?,*xx]!
+      }
+      return this.array.length - 0.5;
+    }
+    /**
+     * @returns number repeats of operators with given arguments.
+     */
+  }, {
+    key: "getOperator",
+    value: function getOperator(arrow) {
+      var expans = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var megota = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var index = this.getOperatorIndex(arrow, expans, megota);
+      if (!this.array[index]) return 0;
+      return this.array[index].repeat;
+    }
+    /**
+     * Modify the repeat of operator
+     * @param number val the repeat of operator will modify to array.
+     * @returns bool Is the operators array changed?
+     */
+  }, {
+    key: "setOperator",
+    value: function setOperator(val, arrow) {
+      var expans = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var megota = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+      // if (arrow!=0&&val==0) return false;
+      var index = this.getOperatorIndex(arrow, expans, megota);
+      if (!this.array[index]) {
+        this.array.splice(Math.ceil(index), 0, {
+          arrow: arrow,
+          expans: expans,
+          megota: megota,
+          valuereplaced: expans === Infinity ? 1 : arrow == Infinity ? 0 : -1,
+          repeat: val
+        });
+        return true;
+      }
+      this.array[index].repeat = val;
+      // this.normalize()
+      return false;
+    }
+    /**
+     * @returns PowiainaNum a PowiainaNum object which deep copied from `this` object.
+     */
+  }, {
+    key: "clone",
+    value: function clone() {
+      var obj = new PowiainaNum();
+      obj.resetFromObject(this);
+      return obj;
+    }
+  }, {
+    key: "resetFromObject",
+    value: function resetFromObject(powlikeObject) {
+      this.array = [];
+      for (var i = 0; i < powlikeObject.array.length; i++) {
+        this.array[i] = {
+          arrow: powlikeObject.array[i].arrow,
+          expans: powlikeObject.array[i].expans,
+          megota: powlikeObject.array[i].megota,
+          repeat: powlikeObject.array[i].repeat,
+          valuereplaced: powlikeObject.array[i].valuereplaced
+        };
+      }
+      this.small = powlikeObject.small;
+      this.sign = powlikeObject.sign;
+      this.layer = powlikeObject.layer;
+      return this;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      if (this.sign == -1) return -this.neg().toNumber();
+      if (this.small) return 1 / this.rec().toNumber();
+      if (this.getOperator(1) == 0) return this.getOperator(0);else if (this.getOperator(1) == 1) return Math.pow(10, this.getOperator(0));
+      return NaN;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      if (this.isNaN()) return "NaN";
+      if (this.sign == -1) return "-".concat(this.neg().toString());
+      if (this.small) {
+        if (this.eq(PowiainaNum.ZERO)) return "0";
+        return "/".concat(this.rec().toString());
+      }
+      if (this.isInfinite()) return "Infinity";
+      // O^a (10{arrow,expans,megota})^repeation base
+      var res = "";
+      for (var i = this.array.length - 1; i >= 0; i--) {
+        var oper = this.array[i];
+        var calc = "10{".concat(oper.arrow === Infinity ? "!" : oper.arrow).concat(oper.expans > 1 || oper.megota > 1 ? ",".concat(oper.expans === Infinity ? "!" : oper.expans) : "").concat(oper.megota > 1 ? ",".concat(oper.megota) : "", "}");
+        if (oper.arrow == 1 && oper.expans == 1 && oper.megota == 1 && oper.repeat < 5) {
+          calc = "e".repeat(oper.repeat);
+        } else if (oper.arrow == 0 && oper.expans == 1 && oper.megota == 1) {
+          calc = oper.repeat.toString();
+        } else if (oper.repeat > 1) {
+          calc = "(".concat(calc, ")^").concat(oper.repeat, " ");
+        } else {
+          calc = "".concat(calc, " ");
+        }
+        res += "".concat(calc);
+      }
+      return res;
+    }
+  }], [{
+    key: "fromNumber",
+    value: function fromNumber(x) {
+      var obj = new PowiainaNum(); // NaN
+      if (x < 0) obj.sign = -1; // negative
+      else if (x == 0) obj.sign = 0;else if (x > 0) obj.sign = 1;
+      var y = Math.abs(x);
+      if (y >= MSI_REC && y < 1) {
+        obj.small = true;
+        obj.setOperator(1 / y, 0);
+      } else if (y < MSI_REC) {
+        obj.small = true;
+        obj.setOperator(-Math.log10(y), 0);
+        obj.setOperator(1, 1);
+      } else {
+        obj.setOperator(y, 0);
+      }
+      obj.normalize();
+      return obj;
+    }
+  }, {
+    key: "fromString",
+    value: function fromString(input) {
+      var _a, _b, _c, _d, _e, _f;
+      var x = new PowiainaNum();
+      var negateIt = false;
+      var recipIt = false;
+      if (input[0] == "-" || input[0] == "+") {
+        var numSigns = input.search(/[^-\+]/);
+        var signs = input.substring(0, numSigns);
+        negateIt = ((_b = (_a = signs.match(/-/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) % 2 == 1;
+        input = input.substring(numSigns);
+      }
+      if (input[0] == "/") {
+        var numSigns = input.search(/[^\/]/);
+        var signs = input.substring(0, numSigns);
+        recipIt = ((_d = (_c = signs.match(/\//g)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) % 2 == 1;
+        input = input.substring(numSigns);
+      }
+      if (input == "NaN") x.array = [newOperator(NaN)];else if (input == "Infinity") x.array = [newOperator(Infinity)];else {
+        x.sign = 1;
+        x.array = [newOperator(0)];
+        var a, b, c, d;
+        while (input) {
+          if (/^(\(?10[\^\{])/.test(input)) {
+            /*
+              10^ - 匹配
+              10{ - 匹配
+              (10^ - 匹配
+              (10{ - 匹配
+              10x - 不匹配（最后一个字符不是 ^ 或 {）
+              110^ - 不匹配（不是以 10 开头）
+            */
+            if (input[0] == "(") input = input.substring(1);
+            //cutted, 10^.... or 10{....
+            var arrows, expans, megota;
+            if (input[2] == "^") {
+              a = input.substring(2).search(/[^\^]/);
+              //cut input to ^^...^^, and search how numbers
+              arrows = a;
+              // 10^^^
+              b = a + 2; // b points to after ^'s.
+            } else {
+              // 10{...}
+              a = input.indexOf("}");
+              // select contents between {...}
+              var tmp = input.substring(3, a).split(",");
+              arrows = Number(tmp[0] == "!" ? Infinity : tmp[0]);
+              expans = Number((_e = tmp[1] == "!" ? Infinity : tmp[1]) !== null && _e !== void 0 ? _e : 1);
+              megota = Number((_f = tmp[2]) !== null && _f !== void 0 ? _f : 1);
+              b = a + 1;
+              // b points to after }.
+            }
+            input = input.substring(b);
+            if (input[0] == ")") {
+              // )^....<Space>
+              a = input.indexOf(" ");
+              c = Number(input.substring(2, a)); // Select contents between )^....<Space>
+              input = input.substring(a + 1); // c points to after <Space>
+            } else {
+              c = 1; // There is only spaces, count as <ONE>
+            }
+            if (arrows == 1 && expans == 1 && megota == 1) {
+              if (x.array.length >= 2 && x.array[1].arrow == 1) {
+                x.array[1].repeat += c;
+              } else {
+                x.array.splice(1, 0, newOperator(c, 1, expans, megota));
+              }
+            } else if (arrows == 2 && expans == 1 && megota == 1) {
+              a = x.array.length >= 2 && x.array[1].arrow == 1 ? x.array[1].repeat : 0;
+              b = x.array[0].repeat;
+              if (b >= 1e10) ++a;
+              if (b >= 10) ++a;
+              x.array[0].repeat = a;
+              if (x.array.length >= 2 && x.array[1].arrow == 1) x.array.splice(1, 1);
+              d = x.getOperatorIndex(2);
+              if (Number.isInteger(d)) x.array[d].repeat += c;else x.array.splice(Math.ceil(d), 0, newOperator(c, 2, expans, megota));
+            } else if (isFinite(arrows)) {
+              a = x.getOperator(arrows - 1);
+              b = x.getOperator(arrows - 2);
+              if (b >= 10) ++a;
+              d = x.getOperatorIndex(arrows);
+              x.array.splice(1, Math.ceil(d) - 1);
+              x.array[0].repeat = a;
+              if (Number.isInteger(d)) x.array[1].repeat += c;else x.array.splice(1, 0, newOperator(c, arrows, expans, megota));
+            } else {
+              x.array.splice(1, 0, newOperator(c, arrows, expans, megota));
+            }
+          } else {
+            break;
+          }
+        }
+        a = input.split(/[Ee]/);
+        b = [x.array[0].repeat, 0];
+        c = 1;
+        for (var _i3 = a.length - 1; _i3 >= 0; --_i3) {
+          //The things that are already there
+          if (b[0] < MSI_LOG10 && b[1] === 0) {
+            b[0] = Math.pow(10, c * b[0]);
+          } else if (c == -1) {
+            if (b[1] === 0) {
+              b[0] = Math.pow(10, c * b[0]);
+            } else if (b[1] == 1 && b[0] <= Math.log10(Number.MAX_VALUE)) {
+              b[0] = Math.pow(10, c * Math.pow(10, b[0]));
+            } else {
+              b[0] = 0;
+            }
+            b[1] = 0;
+          } else {
+            b[1]++;
+          }
+          //Multiplying coefficient
+          var decimalPointPos = a[_i3].indexOf(".");
+          var intPartLen = decimalPointPos == -1 ? a[_i3].length : decimalPointPos;
+          if (b[1] === 0) {
+            if (intPartLen >= LONG_STRING_MIN_LENGTH) b[0] = Math.log10(b[0]) + log10LongString(a[_i3].substring(0, intPartLen)), b[1] = 1;else if (a[_i3]) b[0] *= Number(a[_i3]);
+          } else {
+            d = intPartLen >= LONG_STRING_MIN_LENGTH ? log10LongString(a[_i3].substring(0, intPartLen)) : a[_i3] ? Math.log10(Number(a[_i3])) : 0;
+            if (b[1] == 1) {
+              b[0] += d;
+            } else if (b[1] == 2 && b[0] < MSI_LOG10 + Math.log10(d)) {
+              b[0] += Math.log10(1 + Math.pow(10, Math.log10(d) - b[0]));
+            }
+          }
+          //Carrying
+          if (b[0] < MSI_LOG10 && b[1]) {
+            b[0] = Math.pow(10, b[0]);
+            b[1]--;
+          } else if (b[0] > MSI) {
+            b[0] = Math.log10(b[0]);
+            b[1]++;
+          }
+        }
+        x.array[0].repeat = b[0];
+        if (b[1]) {
+          if (x.array.length >= 2 && x.array[1].arrow == 1) x.array[1].repeat += b[1];else x.array.splice(1, 0, newOperator(b[1], 1, 1, 1));
+        }
+      }
+      if (negateIt) x.sign *= -1;
+      if (recipIt) x.small = !x.small;
+      x.normalize();
+      x.normalize();
+      return x;
+    }
+  }, {
+    key: "fromObject",
+    value: function fromObject(powlikeObject) {
+      var obj = new PowiainaNum();
+      obj.array = [];
+      for (var i = 0; i < powlikeObject.array.length; i++) {
+        obj.array[i] = {
+          arrow: powlikeObject.array[i].arrow,
+          expans: powlikeObject.array[i].expans,
+          megota: powlikeObject.array[i].megota,
+          repeat: powlikeObject.array[i].repeat,
+          valuereplaced: powlikeObject.array[i].valuereplaced
+        };
+      }
+      obj.small = powlikeObject.small;
+      obj.sign = powlikeObject.sign;
+      obj.layer = powlikeObject.layer;
+      return obj;
+    }
+  }]);
+}();
+PowiainaNum.ZERO = new PowiainaNum({
+  array: [{
+    arrow: 0,
+    expans: 1,
+    megota: 1,
+    repeat: Infinity
+  }],
+  small: true,
+  layer: 0,
+  sign: 0
+});
+PowiainaNum.ONE = new PowiainaNum({
+  array: [{
+    arrow: 0,
+    expans: 1,
+    megota: 1,
+    repeat: 1
+  }],
+  small: false,
+  layer: 0,
+  sign: 1
+});
+PowiainaNum.MSI = new PowiainaNum(MSI);
+PowiainaNum.MSI_REC = function () {
+  var obj = new PowiainaNum(MSI);
+  obj.small = true;
+  return obj;
+}();
+PowiainaNum.E_MSI = new PowiainaNum({
+  array: [{
+    arrow: 0,
+    expans: 1,
+    megota: 1,
+    repeat: MSI
+  }, {
+    arrow: 1,
+    expans: 1,
+    megota: 1,
+    repeat: 1
+  }],
+  small: false,
+  layer: 0,
+  sign: 1
+});
+PowiainaNum.E_MSI_REC = new PowiainaNum({
+  array: [{
+    arrow: 0,
+    expans: 1,
+    megota: 1,
+    repeat: MSI
+  }, {
+    arrow: 1,
+    expans: 1,
+    megota: 1,
+    repeat: 1
+  }],
+  small: true,
+  layer: 0,
+  sign: 1
+});
+PowiainaNum.POSITIVE_INFINITY = new PowiainaNum(Infinity);
+PowiainaNum.NEGATIVE_INFINITY = new PowiainaNum(-Infinity);
+PowiainaNum.NaN = new PowiainaNum({
+  array: [{
+    arrow: 0,
+    expans: 1,
+    megota: 1,
+    repeat: NaN
+  }],
+  small: false,
+  layer: 0,
+  sign: 0
+});
+PowiainaNum.maxOps = 100;
+
+module.exports = PowiainaNum;