Source: numtype.js

  1. /**
  2.  * @constructor
  3.  * Sk.builtin.numtype
  4.  *
  5.  * @description
  6.  * Abstract class for Python numeric types.
  7.  *
  8.  * @extends {Sk.builtin.object}
  9.  *
  10.  * @return {undefined} Cannot instantiate a Sk.builtin.numtype object
  11.  */
  12. Sk.builtin.numtype = function () {
  14.     throw new Sk.builtin.ExternalError("Cannot instantiate abstract Sk.builtin.numtype class");
  16. };
  18. Sk.abstr.setUpInheritance("NumericType", Sk.builtin.numtype, Sk.builtin.object);
  20. Sk.builtin.numtype.sk$abstract = true;
  22. /**
  23.  * Python wrapper of `__abs__` method.
  24.  *
  25.  * @name  __abs__
  26.  * @instance
  27.  * @memberOf Sk.builtin.numtype.prototype
  28.  */
  29. Sk.builtin.numtype.prototype["__abs__"] = new Sk.builtin.func(function (self) {
  31.     if (self.nb$abs === undefined) {
  32.         throw new Sk.builtin.NotImplementedError("__abs__ is not yet implemented");
  33.     }
  35.     Sk.builtin.pyCheckArgsLen("__abs__", arguments.length, 0, 0, false, true);
  36.     return self.nb$abs();
  38. });
  40. /**
  41.  * Python wrapper of `__neg__` method.
  42.  *
  43.  * @name  __neg__
  44.  * @instance
  45.  * @memberOf Sk.builtin.numtype.prototype
  46.  */
  47. Sk.builtin.numtype.prototype["__neg__"] = new Sk.builtin.func(function (self) {
  49.     if (self.nb$negative === undefined) {
  50.         throw new Sk.builtin.NotImplementedError("__neg__ is not yet implemented");
  51.     }
  53.     Sk.builtin.pyCheckArgsLen("__neg__", arguments.length, 0, 0, false, true);
  54.     return self.nb$negative();
  56. });
  58. /**
  59.  * Python wrapper of `__pos__` method.
  60.  *
  61.  * @name  __pos__
  62.  * @instance
  63.  * @memberOf Sk.builtin.numtype.prototype
  64.  */
  65. Sk.builtin.numtype.prototype["__pos__"] = new Sk.builtin.func(function (self) {
  67.     if (self.nb$positive === undefined) {
  68.         throw new Sk.builtin.NotImplementedError("__pos__ is not yet implemented");
  69.     }
  71.     Sk.builtin.pyCheckArgsLen("__pos__", arguments.length, 0, 0, false, true);
  72.     return self.nb$positive();
  74. });
  76. /**
  77.  * Python wrapper of `__int__` method.
  78.  *
  79.  * @name  __int__
  80.  * @instance
  81.  * @memberOf Sk.builtin.numtype.prototype
  82.  */
  83. Sk.builtin.numtype.prototype["__int__"] = new Sk.builtin.func(function (self) {
  85.     if (self.nb$int_ === undefined) {
  86.         throw new Sk.builtin.NotImplementedError("__int__ is not yet implemented");
  87.     }
  89.     Sk.builtin.pyCheckArgsLen("__int__", arguments.length, 0, 0, false, true);
  90.     return self.nb$int_();
  92. });
  94. /**
  95.  * Python wrapper of `__long__` method.
  96.  *
  97.  * @name  __long__
  98.  * @instance
  99.  * @memberOf Sk.builtin.numtype.prototype
  100.  */
  101. Sk.builtin.numtype.prototype["__long__"] = new Sk.builtin.func(function (self) {
  103.     if (self.nb$lng === undefined) {
  104.         throw new Sk.builtin.NotImplementedError("__long__ is not yet implemented");
  105.     }
  107.     Sk.builtin.pyCheckArgsLen("__long__", arguments.length, 0, 0, false, true);
  108.     return self.nb$lng();
  110. });
  112. /**
  113.  * Python wrapper of `__float__` method.
  114.  *
  115.  * @name  __float__
  116.  * @instance
  117.  * @memberOf Sk.builtin.numtype.prototype
  118.  */
  119. Sk.builtin.numtype.prototype["__float__"] = new Sk.builtin.func(function (self) {
  121.     if (self.nb$float_ === undefined) {
  122.         throw new Sk.builtin.NotImplementedError("__float__ is not yet implemented");
  123.     }
  125.     Sk.builtin.pyCheckArgsLen("__float__", arguments.length, 0, 0, false, true);
  126.     return self.nb$float_();
  128. });
  130. /**
  131.  * Python wrapper of `__add__` method.
  132.  *
  133.  * @name  __add__
  134.  * @instance
  135.  * @memberOf Sk.builtin.numtype.prototype
  136.  */
  137. Sk.builtin.numtype.prototype["__add__"] = new Sk.builtin.func(function (self, other) {
  139.     if (self.nb$add === undefined) {
  140.         throw new Sk.builtin.NotImplementedError("__add__ is not yet implemented");
  141.     }
  143.     Sk.builtin.pyCheckArgsLen("__add__", arguments.length, 1, 1, false, true);
  144.     return self.nb$add(other);
  146. });
  148. /**
  149.  * Python wrapper of `__radd__` method.
  150.  *
  151.  * @name  __radd__
  152.  * @instance
  153.  * @memberOf Sk.builtin.numtype.prototype
  154.  */
  155. Sk.builtin.numtype.prototype["__radd__"] = new Sk.builtin.func(function (self, other) {
  157.     if (self.nb$reflected_add === undefined) {
  158.         throw new Sk.builtin.NotImplementedError("__radd__ is not yet implemented");
  159.     }
  161.     Sk.builtin.pyCheckArgsLen("__radd__", arguments.length, 1, 1, false, true);
  162.     return self.nb$reflected_add(other);
  164. });
  166. /**
  167.  * Python wrapper of `__sub__` method.
  168.  *
  169.  * @name  __sub__
  170.  * @instance
  171.  * @memberOf Sk.builtin.numtype.prototype
  172.  */
  173. Sk.builtin.numtype.prototype["__sub__"] = new Sk.builtin.func(function (self, other) {
  175.     if (self.nb$subtract === undefined) {
  176.         throw new Sk.builtin.NotImplementedError("__sub__ is not yet implemented");
  177.     }
  179.     Sk.builtin.pyCheckArgsLen("__sub__", arguments.length, 1, 1, false, true);
  180.     return self.nb$subtract(other);
  182. });
  184. /**
  185.  * Python wrapper of `__rsub__` method.
  186.  *
  187.  * @name  __rsub__
  188.  * @instance
  189.  * @memberOf Sk.builtin.numtype.prototype
  190.  */
  191. Sk.builtin.numtype.prototype["__rsub__"] = new Sk.builtin.func(function (self, other) {
  193.     if (self.nb$reflected_subtract === undefined) {
  194.         throw new Sk.builtin.NotImplementedError("__rsub__ is not yet implemented");
  195.     }
  197.     Sk.builtin.pyCheckArgsLen("__rsub__", arguments.length, 1, 1, false, true);
  198.     return self.nb$reflected_subtract(other);
  200. });
  202. /**
  203.  * Python wrapper of `__mul__` method.
  204.  *
  205.  * @name  __mul__
  206.  * @instance
  207.  * @memberOf Sk.builtin.numtype.prototype
  208.  */
  209. Sk.builtin.numtype.prototype["__mul__"] = new Sk.builtin.func(function (self, other) {
  211.     if (self.nb$multiply === undefined) {
  212.         throw new Sk.builtin.NotImplementedError("__mul__ is not yet implemented");
  213.     }
  215.     Sk.builtin.pyCheckArgsLen("__mul__", arguments.length, 1, 1, false, true);
  216.     return self.nb$multiply(other);
  218. });
  220. /**
  221.  * Python wrapper of `__rmul__` method.
  222.  *
  223.  * @name  __rmul__
  224.  * @instance
  225.  * @memberOf Sk.builtin.numtype.prototype
  226.  */
  227. Sk.builtin.numtype.prototype["__rmul__"] = new Sk.builtin.func(function (self, other) {
  229.     if (self.nb$reflected_multiply === undefined) {
  230.         throw new Sk.builtin.NotImplementedError("__rmul__ is not yet implemented");
  231.     }
  233.     Sk.builtin.pyCheckArgsLen("__rmul__", arguments.length, 1, 1, false, true);
  234.     return self.nb$reflected_multiply(other);
  236. });
  238. /**
  239.  * Python wrapper of `__div__` method.
  240.  *
  241.  * @name  __div__
  242.  * @instance
  243.  * @memberOf Sk.builtin.numtype.prototype
  244.  */
  245. Sk.builtin.numtype.prototype["__div__"] = new Sk.builtin.func(function (self, other) {
  247.     if (self.nb$divide === undefined) {
  248.         throw new Sk.builtin.NotImplementedError("__div__ is not yet implemented");
  249.     }
  251.     Sk.builtin.pyCheckArgsLen("__div__", arguments.length, 1, 1, false, true);
  252.     return self.nb$divide(other);
  254. });
  256. /**
  257.  * Python wrapper of `__rdiv__` method.
  258.  *
  259.  * @name  __rdiv__
  260.  * @instance
  261.  * @memberOf Sk.builtin.numtype.prototype
  262.  */
  263. Sk.builtin.numtype.prototype["__rdiv__"] = new Sk.builtin.func(function (self, other) {
  265.     if (self.nb$reflected_divide === undefined) {
  266.         throw new Sk.builtin.NotImplementedError("__rdiv__ is not yet implemented");
  267.     }
  269.     Sk.builtin.pyCheckArgsLen("__rdiv__", arguments.length, 1, 1, false, true);
  270.     return self.nb$reflected_divide(other);
  272. });
  274. /**
  275.  * Python wrapper of `__floordiv__` method.
  276.  *
  277.  * @name  __floordiv__
  278.  * @instance
  279.  * @memberOf Sk.builtin.numtype.prototype
  280.  */
  281. Sk.builtin.numtype.prototype["__floordiv__"] = new Sk.builtin.func(function (self, other) {
  283.     if (self.nb$floor_divide === undefined) {
  284.         throw new Sk.builtin.NotImplementedError("__floordiv__ is not yet implemented");
  285.     }
  287.     Sk.builtin.pyCheckArgsLen("__floordiv__", arguments.length, 1, 1, false, true);
  288.     return self.nb$floor_divide(other);
  290. });
  292. /**
  293.  * Python wrapper of `__rfloordiv__` method.
  294.  *
  295.  * @name  __rfloordiv__
  296.  * @instance
  297.  * @memberOf Sk.builtin.numtype.prototype
  298.  */
  299. Sk.builtin.numtype.prototype["__rfloordiv__"] = new Sk.builtin.func(function (self, other) {
  301.     if (self.nb$reflected_floor_divide === undefined) {
  302.         throw new Sk.builtin.NotImplementedError("__rfloordiv__ is not yet implemented");
  303.     }
  305.     Sk.builtin.pyCheckArgsLen("__rfloordiv__", arguments.length, 1, 1, false, true);
  306.     return self.nb$reflected_floor_divide(other);
  308. });
  310. /**
  311.  * Python wrapper of `__mod__` method.
  312.  *
  313.  * @name  __mod__
  314.  * @instance
  315.  * @memberOf Sk.builtin.numtype.prototype
  316.  */
  317. Sk.builtin.numtype.prototype["__mod__"] = new Sk.builtin.func(function (self, other) {
  319.     if (self.nb$remainder === undefined) {
  320.         throw new Sk.builtin.NotImplementedError("__mod__ is not yet implemented");
  321.     }
  323.     Sk.builtin.pyCheckArgsLen("__mod__", arguments.length, 1, 1, false, true);
  324.     return self.nb$remainder(other);
  326. });
  328. /**
  329.  * Python wrapper of `__rmod__` method.
  330.  *
  331.  * @name  __rmod__
  332.  * @instance
  333.  * @memberOf Sk.builtin.numtype.prototype
  334.  */
  335. Sk.builtin.numtype.prototype["__rmod__"] = new Sk.builtin.func(function (self, other) {
  337.     if (self.nb$reflected_remainder === undefined) {
  338.         throw new Sk.builtin.NotImplementedError("__rmod__ is not yet implemented");
  339.     }
  341.     Sk.builtin.pyCheckArgsLen("__rmod__", arguments.length, 1, 1, false, true);
  342.     return self.nb$reflected_remainder(other);
  344. });
  346. /**
  347.  * Python wrapper of `__divmod__` method.
  348.  *
  349.  * @name  __divmod__
  350.  * @instance
  351.  * @memberOf Sk.builtin.numtype.prototype
  352.  */
  353. Sk.builtin.numtype.prototype["__divmod__"] = new Sk.builtin.func(function (self, other) {
  355.     if (self.nb$divmod === undefined) {
  356.         throw new Sk.builtin.NotImplementedError("__divmod__ is not yet implemented");
  357.     }
  359.     Sk.builtin.pyCheckArgsLen("__divmod__", arguments.length, 1, 1, false, true);
  360.     return self.nb$divmod(other);
  362. });
  364. /**
  365.  * Python wrapper of `__rdivmod__` method.
  366.  *
  367.  * @name  __rdivmod__
  368.  * @instance
  369.  * @memberOf Sk.builtin.numtype.prototype
  370.  */
  371. Sk.builtin.numtype.prototype["__rdivmod__"] = new Sk.builtin.func(function (self, other) {
  373.     if (self.nb$reflected_divmod === undefined) {
  374.         throw new Sk.builtin.NotImplementedError("__rdivmod__ is not yet implemented");
  375.     }
  377.     Sk.builtin.pyCheckArgsLen("__rdivmod__", arguments.length, 1, 1, false, true);
  378.     return self.nb$reflected_divmod(other);
  380. });
  382. /**
  383.  * Python wrapper of `__pow__` method.
  384.  *
  385.  * @name  __pow__
  386.  * @instance
  387.  * @memberOf Sk.builtin.numtype.prototype
  388.  */
  389. Sk.builtin.numtype.prototype["__pow__"] = new Sk.builtin.func(function (self, other) {
  391.     if (self.nb$power === undefined) {
  392.         throw new Sk.builtin.NotImplementedError("__pow__ is not yet implemented");
  393.     }
  395.     Sk.builtin.pyCheckArgsLen("__pow__", arguments.length, 1, 1, false, true);
  396.     return self.nb$power(other);
  398. });
  400. /**
  401.  * Python wrapper of `__rpow__` method.
  402.  *
  403.  * @name  __rpow__
  404.  * @instance
  405.  * @memberOf Sk.builtin.numtype.prototype
  406.  */
  407. Sk.builtin.numtype.prototype["__rpow__"] = new Sk.builtin.func(function (self, other) {
  409.     if (self.nb$reflected_power === undefined) {
  410.         throw new Sk.builtin.NotImplementedError("__rpow__ is not yet implemented");
  411.     }
  413.     Sk.builtin.pyCheckArgsLen("__rpow__", arguments.length, 1, 1, false, true);
  414.     return self.nb$reflected_power(other);
  416. });
  418. /**
  419.  * Python wrapper of `__coerce__` method.
  420.  *
  421.  * @name  __coerce__
  422.  * @instance
  423.  * @memberOf Sk.builtin.numtype.prototype
  424.  */
  425. Sk.builtin.numtype.prototype["__coerce__"] = new Sk.builtin.func(function (self, other) {
  427.     throw new Sk.builtin.NotImplementedError("__coerce__ is not yet implemented");
  429. });
  431. /**
  432.  * Add a Python object to this instance and return the result (i.e. this + other).
  433.  *
  434.  * Returns NotImplemented if addition between this type and other type is unsupported.
  435.  *
  436.  * Javscript function, returns Python object.
  437.  *
  438.  * @param  {!Sk.builtin.object} other The Python object to add.
  439.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the addition.
  440.  */
  441. Sk.builtin.numtype.prototype.nb$add = function (other) {
  442.     return Sk.builtin.NotImplemented.NotImplemented$;
  443. };
  445. Sk.builtin.numtype.prototype.nb$reflected_add = function (other) {
  446.     return Sk.builtin.NotImplemented.NotImplemented$;
  447. };
  449. Sk.builtin.numtype.prototype.nb$inplace_add = function (other) {
  450.     return Sk.builtin.NotImplemented.NotImplemented$;
  451. };
  453. /**
  454.  * Subtract a Python object from this instance and return the result (i.e. this - other).
  455.  *
  456.  * Returns NotImplemented if subtraction between this type and other type is unsupported.
  457.  *
  458.  * Javscript function, returns Python object.
  459.  *
  460.  * @param  {!Sk.builtin.object} other The Python object to subtract.
  461.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the subtraction.
  462.  */
  463. Sk.builtin.numtype.prototype.nb$subtract = function (other) {
  464.     return Sk.builtin.NotImplemented.NotImplemented$;
  465. };
  467. Sk.builtin.numtype.prototype.nb$reflected_subtract = function (other) {
  468.     return Sk.builtin.NotImplemented.NotImplemented$;
  469. };
  471. Sk.builtin.numtype.prototype.nb$inplace_subtract = function (other) {
  472.     return Sk.builtin.NotImplemented.NotImplemented$;
  473. };
  475. /**
  476.  * Multiply this instance by a Python object and return the result (i.e. this * other).
  477.  *
  478.  * Returns NotImplemented if multiplication between this type and other type is unsupported.
  479.  *
  480.  * Javscript function, returns Python object.
  481.  *
  482.  * @param  {!Sk.builtin.object} other The multiplier, which must be a Python object.
  483.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the multiplication
  484.  */
  485. Sk.builtin.numtype.prototype.nb$multiply = function (other) {
  486.     return Sk.builtin.NotImplemented.NotImplemented$;
  487. };
  490. Sk.builtin.numtype.prototype.nb$reflected_multiply = function (other) {
  491.     return Sk.builtin.NotImplemented.NotImplemented$;
  492. };
  494. Sk.builtin.numtype.prototype.nb$inplace_multiply = function (other) {
  495.     return Sk.builtin.NotImplemented.NotImplemented$;
  496. };
  498. /**
  499.  * Divide this instance by a Python object and return the result (i.e this / other).
  500.  *
  501.  * Returns NotImplemented if division between this type and other type is unsupported.
  502.  *
  503.  * Javscript function, returns Python object.
  504.  *
  505.  * @param  {!Sk.builtin.object} other The divisor, which must be a Python object.
  506.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the division
  507.  */
  508. Sk.builtin.numtype.prototype.nb$divide = function (other) {
  509.     return Sk.builtin.NotImplemented.NotImplemented$;
  510. };
  512. Sk.builtin.numtype.prototype.nb$reflected_divide = function (other) {
  513.     return Sk.builtin.NotImplemented.NotImplemented$;
  514. };
  516. Sk.builtin.numtype.prototype.nb$inplace_divide = function (other) {
  517.     return Sk.builtin.NotImplemented.NotImplemented$;
  518. };
  520. /**
  521.  * Floor divide this instance by a Python object and return the result (i.e. this // other).
  522.  *
  523.  * Returns NotImplemented if floor division between this type and other type is unsupported.
  524.  *
  525.  * Javscript function, returns Python object.
  526.  *
  527.  * @param  {!Sk.builtin.object} other The divisor, which must be a Python object.
  528.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the floor division
  529.  */
  530. Sk.builtin.numtype.prototype.nb$floor_divide = function (other) {
  531.     return Sk.builtin.NotImplemented.NotImplemented$;
  532. };
  534. Sk.builtin.numtype.prototype.nb$reflected_floor_divide = function (other) {
  535.     return Sk.builtin.NotImplemented.NotImplemented$;
  536. };
  538. Sk.builtin.numtype.prototype.nb$inplace_floor_divide = function (other) {
  539.     return Sk.builtin.NotImplemented.NotImplemented$;
  540. };
  542. /**
  543.  * Modulo this instance by a Python object and return the result (i.e. this % other).
  544.  *
  545.  * Returns NotImplemented if modulation between this type and other type is unsupported.
  546.  *
  547.  * Javscript function, returns Python object.
  548.  *
  549.  * @param  {!Sk.builtin.object} other The divisor, which must be a Python object.
  550.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the modulation
  551.  */
  552. Sk.builtin.numtype.prototype.nb$remainder = function (other) {
  553.     return Sk.builtin.NotImplemented.NotImplemented$;
  554. };
  556. Sk.builtin.numtype.prototype.nb$reflected_remainder = function (other) {
  557.     return Sk.builtin.NotImplemented.NotImplemented$;
  558. };
  560. Sk.builtin.numtype.prototype.nb$inplace_remainder = function (other) {
  561.     return Sk.builtin.NotImplemented.NotImplemented$;
  562. };
  564. /**
  565.  * Compute the quotient and the remainder of this instance and a given Python object and return the result.
  566.  *
  567.  * Returns NotImplemented if division or modulo operations between this type and other type are unsupported.
  568.  *
  569.  * Javscript function, returns Python object.
  570.  *
  571.  * @param  {!Sk.builtin.object} other The divisor, which must be a Python object.
  572.  * @return {(Sk.builtin.tuple|Sk.builtin.NotImplemented)} The result of the operation.
  573.  * If both operations are supported, a Python tuple containing (quotient, remainder) in that order.
  574.  */
  575. Sk.builtin.numtype.prototype.nb$divmod = function (other) {
  576.     return Sk.builtin.NotImplemented.NotImplemented$;
  577. };
  579. Sk.builtin.numtype.prototype.nb$reflected_divmod = function (other) {
  580.     return Sk.builtin.NotImplemented.NotImplemented$;
  581. };
  583. /**
  584.  * Raise this instance by a Python object, optionally modulo the exponent, and return the final result.
  585.  *
  586.  * If mod is undefined, return this \*\* other. Else, return (this \*\* other) % mod.
  587.  *
  588.  * Returns NotImplemented if exponentiation or modulation between this type and other type is unsupported.
  589.  *
  590.  * Javscript function, returns Python object.
  591.  *
  592.  * @param  {!Sk.builtin.object} other The exponent, which must be a Python object.
  593.  * @param  {!Sk.builtin.object=} mod The optional divisor, which must be a Python object if defined.
  594.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The result of the exponentiation.
  595.  */
  596. Sk.builtin.numtype.prototype.nb$power = function (other, mod) {
  597.     return Sk.builtin.NotImplemented.NotImplemented$;
  598. };
  600. Sk.builtin.numtype.prototype.nb$reflected_power = function (other, mod) {
  601.     return Sk.builtin.NotImplemented.NotImplemented$;
  602. };
  604. Sk.builtin.numtype.prototype.nb$inplace_power = function (other) {
  605.     return Sk.builtin.NotImplemented.NotImplemented$;
  606. };
  608. /**
  609.  * Compute the absolute value of this instance and return.
  610.  *
  611.  * Javascript function, returns Python object.
  612.  *
  613.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} The absolute value
  614.  */
  615. Sk.builtin.numtype.prototype.nb$abs = function () {
  616.     return Sk.builtin.NotImplemented.NotImplemented$;
  617. };
  619. /**
  620.  * Compute the unary negative of this instance (i.e. -this).
  621.  *
  622.  * Javscript function, returns Python object.
  623.  *
  624.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} A copy of this instance with the value negated
  625.  */
  626. Sk.builtin.numtype.prototype.nb$negative = function () {
  627.     return Sk.builtin.NotImplemented.NotImplemented$;
  628. };
  630. /**
  631.  * Compute the unary positive of this instance (i.e. +this).
  632.  *
  633.  * Javscript function, returns Python object.
  634.  *
  635.  * @return {(Sk.builtin.numtype|Sk.builtin.NotImplemented)} A copy of this instance with the value unchanged
  636.  */
  637. Sk.builtin.numtype.prototype.nb$positive = function () {
  638.     return Sk.builtin.NotImplemented.NotImplemented$;
  639. };
  641. /**
  642.  * Determine if this instance is nonzero.
  643.  *
  644.  * Javscript function, returns Javascript object or Sk.builtin.NotImplemented.
  645.  *
  646.  * @return {(boolean|Sk.builtin.NotImplemented)} true if this instance is not equal to zero, false otherwise
  647.  */
  648. Sk.builtin.numtype.prototype.nb$nonzero = function () {
  649.     return Sk.builtin.NotImplemented.NotImplemented$;
  650. };
  652. /**
  653.  * Determine if this instance is negative.
  654.  *
  655.  * Javscript function, returns Javascript object or Sk.builtin.NotImplemented.
  656.  *
  657.  * @return {(boolean|Sk.builtin.NotImplemented)} true if this instance is negative, false otherwise
  658.  */
  659. Sk.builtin.numtype.prototype.nb$isnegative = function () {
  660.     return Sk.builtin.NotImplemented.NotImplemented$;
  661. };
  663. /**
  664.  * Determine if this instance is positive.
  665.  *
  666.  * Javscript function, returns Javascript object or Sk.builtin.NotImplemented.
  667.  *
  668.  * @return {(boolean|Sk.builtin.NotImplemented)} true if this instance is positive, false otherwise
  669.  */
  670. Sk.builtin.numtype.prototype.nb$ispositive = function () {
  671.     return Sk.builtin.NotImplemented.NotImplemented$;
  672. };