powiaina_num.js 0.1.12 → 0.2.0-alpha.2.1

package/dist/PowiainaNum.js

@@ -0,0 +1,1000 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Decimal = factory());
+})(this, (function () { '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;
+
+  return PowiainaNum;
+
+}));