Source: float.js

  1. /**
  2.  * @namespace Sk.builtin
  3.  */
  5. /**
  6.  * @constructor
  7.  * Sk.builtin.float_
  8.  *
  9.  * @description
  10.  * Constructor for Python float. Also used for builtin float().
  11.  *
  12.  * @extends {Sk.builtin.numtype}
  13.  *
  14.  * @param {!(Object|number|string)} x Object or number to convert to Python float.
  15.  * @return {Sk.builtin.float_} Python float
  16.  */
  17. Sk.builtin.float_ = function (x) {
  18.     var tmp;
  19.     if (x === undefined) {
  20.         return new Sk.builtin.float_(0.0);
  21.     }
  23.     if (!(this instanceof Sk.builtin.float_)) {
  24.         return new Sk.builtin.float_(x);
  25.     }
  28.     if (x instanceof Sk.builtin.str) {
  29.         return Sk.builtin._str_to_float(x.v);
  30.     }
  32.     // Floats are just numbers
  33.     if (typeof x === "number" || x instanceof Sk.builtin.int_ || x instanceof Sk.builtin.lng || x instanceof Sk.builtin.float_) {
  34.         tmp = Sk.builtin.asnum$(x);
  35.         if (typeof tmp === "string") {
  36.             return Sk.builtin._str_to_float(tmp);
  37.         }
  38.         this.v = tmp;
  39.         return this;
  40.     }
  42.     // Convert booleans
  43.     if (x instanceof Sk.builtin.bool) {
  44.         this.v = Sk.builtin.asnum$(x);
  45.         return this;
  46.     }
  48.     // this is a special internal case
  49.     if(typeof x === "boolean") {
  50.         this.v = x ? 1.0 : 0.0;
  51.         return this;
  52.     }
  54.     if (typeof x === "string") {
  55.         this.v = parseFloat(x);
  56.         return this;
  57.     }
  59.     // try calling __float__
  60.     var special = Sk.abstr.lookupSpecial(x, Sk.builtin.str.$float_);
  61.     if (special != null) {
  62.         // method on builtin, provide this arg
  63.         return Sk.misceval.callsimArray(special, [x]);
  64.     }
  66.     throw new Sk.builtin.TypeError("float() argument must be a string or a number");
  67. };
  69. Sk.abstr.setUpInheritance("float", Sk.builtin.float_, Sk.builtin.numtype);
  71. Sk.builtin._str_to_float = function (str) {
  72.     var tmp;
  74.     if (str.match(/^-inf$/i)) {
  75.         tmp = -Infinity;
  76.     } else if (str.match(/^[+]?inf$/i)) {
  77.         tmp = Infinity;
  78.     } else if (str.match(/^[-+]?nan$/i)) {
  79.         tmp = NaN;
  80.     } else if (!isNaN(str)) {
  81.         tmp = parseFloat(str);
  82.     } else {
  83.         throw new Sk.builtin.ValueError("float: Argument: " + str + " is not number");
  84.     }
  85.     return new Sk.builtin.float_(tmp);
  86. };
  88. Sk.builtin.float_.prototype.nb$int_ = function () {
  89.     var v = this.v;
  91.     if (v < 0) {
  92.         v = Math.ceil(v);
  93.     } else {
  94.         v = Math.floor(v);
  95.     }
  97.     // this should take care of int/long fitting
  98.     return new Sk.builtin.int_(v);
  99. };
  101. Sk.builtin.float_.prototype.nb$float_ = function() {
  102.     return this;
  103. };
  105. Sk.builtin.float_.prototype.nb$lng = function () {
  106.     return new Sk.builtin.lng(this.v);
  107. };
  109. /**
  110.  * Checks for float subtypes, though skulpt does not allow to
  111.  * extend them for now.
  112.  *
  113.  * Javascript function, returns Javascript object.
  114.  * @param {Object} op The object to check as subtype.
  115.  * @return {boolean} true if op is a subtype of Sk.builtin.float_, false otherwise
  116.  */
  117. Sk.builtin.float_.PyFloat_Check = function (op) {
  118.     if (op === undefined) {
  119.         return false;
  120.     }
  122.     // this is a little bit hacky
  123.     // ToDo: subclassable builtins do not require this
  124.     if (Sk.builtin.checkNumber(op)) {
  125.         return true;
  126.     }
  128.     if (Sk.builtin.checkFloat(op)) {
  129.         return true;
  130.     }
  132.     if (Sk.builtin.issubclass(op.ob$type, Sk.builtin.float_)) {
  133.         return true;
  134.     }
  136.     return false;
  137. };
  139. /**
  140.  * Checks if ob is a Python float.
  141.  *
  142.  * This method is just a wrapper, but uses the correct cpython API name.
  143.  *
  144.  * Javascript function, returns Javascript object.
  145.  * @param {Object} op The object to check.
  146.  * @return {boolean} true if op is an instance of Sk.builtin.float_, false otherwise
  147.  */
  148. Sk.builtin.float_.PyFloat_Check_Exact = function (op) {
  149.     return Sk.builtin.checkFloat(op);
  150. };
  152. Sk.builtin.float_.PyFloat_AsDouble = function (op) {
  153.     var f; // nb_float;
  154.     var fo; // PyFloatObject *fo;
  155.     var val;
  157.     // it is a subclass or direct float
  158.     if (op && Sk.builtin.float_.PyFloat_Check(op)) {
  159.         return Sk.ffi.remapToJs(op);
  160.     }
  162.     if (op == null) {
  163.         throw new Error("bad argument for internal PyFloat_AsDouble function");
  164.     }
  166.     // check if special method exists (nb_float is not implemented in skulpt, hence we use __float__)
  167.     f = Sk.builtin.type.typeLookup(op.ob$type, Sk.builtin.str.$float_);
  168.     if (f == null) {
  169.         throw new Sk.builtin.TypeError("a float is required");
  170.     }
  172.     // call internal float method
  173.     fo = Sk.misceval.callsimArray(f, [op]);
  175.     // return value of __float__ must be a python float
  176.     if (!Sk.builtin.float_.PyFloat_Check(fo)) {
  177.         throw new Sk.builtin.TypeError("nb_float should return float object");
  178.     }
  180.     val = Sk.ffi.remapToJs(fo);
  182.     return val;
  183. };
  185. /**
  186.  * Return this instance's Javascript value.
  187.  *
  188.  * Javascript function, returns Javascript object.
  189.  *
  190.  * @return {number} This instance's value.
  191.  */
  192. Sk.builtin.float_.prototype.tp$index = function () {
  193.     return this.v;
  194. };
  196. /** @override */
  197. Sk.builtin.float_.prototype.tp$hash = function () {
  198.     //the hash of all numbers should be an int and since javascript doesn't really
  199.     //care every number can be an int.
  200.     return this.nb$int_();
  201. };
  204. /**
  205.  * Returns a copy of this instance.
  206.  *
  207.  * Javascript function, returns Python object.
  208.  *
  209.  * @return {Sk.builtin.float_} The copy
  210.  */
  211. Sk.builtin.float_.prototype.clone = function () {
  212.     return new Sk.builtin.float_(this.v);
  213. };
  215. /**
  216.  * Returns this instance's value as a string formatted using fixed-point notation.
  217.  *
  218.  * Javascript function, returns Javascript object.
  219.  *
  220.  * @param  {Object|number} x The numer of digits to appear after the decimal point.
  221.  * @return {string}   The string representation of this instance's value.
  222.  */
  223. Sk.builtin.float_.prototype.toFixed = function (x) {
  224.     x = Sk.builtin.asnum$(x);
  225.     return this.v.toFixed(x);
  226. };
  228. /** @override */
  229. Sk.builtin.float_.prototype.nb$add = function (other) {
  230.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  231.         return new Sk.builtin.float_(this.v + other.v);
  232.     } else if (other instanceof Sk.builtin.lng) {
  233.         return new Sk.builtin.float_(this.v + parseFloat(other.str$(10, true)));
  234.     }
  236.     return Sk.builtin.NotImplemented.NotImplemented$;
  237. };
  239. /** @override */
  240. Sk.builtin.float_.prototype.nb$reflected_add = function (other) {
  241.     // Should not automatically call this.nb$add, as nb$add may have
  242.     // been overridden by a subclass
  243.     return Sk.builtin.float_.prototype.nb$add.call(this, other);
  244. };
  246. /** @override */
  247. Sk.builtin.float_.prototype.nb$subtract = function (other) {
  248.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  249.         return new Sk.builtin.float_(this.v - other.v);
  250.     } else if (other instanceof Sk.builtin.lng) {
  251.         return new Sk.builtin.float_(this.v - parseFloat(other.str$(10, true)));
  252.     }
  254.     return Sk.builtin.NotImplemented.NotImplemented$;
  255. };
  257. /** @override */
  258. Sk.builtin.float_.prototype.nb$reflected_subtract = function (other) {
  259.     // Should not automatically call this.nb$add, as nb$add may have
  260.     // been overridden by a subclass
  261.     var negative_this = this.nb$negative();
  262.     return Sk.builtin.float_.prototype.nb$add.call(negative_this, other);
  263. };
  265. /** @override */
  266. Sk.builtin.float_.prototype.nb$multiply = function (other) {
  267.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  268.         return new Sk.builtin.float_(this.v * other.v);
  269.     } else if (other instanceof Sk.builtin.lng) {
  270.         return new Sk.builtin.float_(this.v * parseFloat(other.str$(10, true)));
  271.     }
  273.     return Sk.builtin.NotImplemented.NotImplemented$;
  274. };
  276. /** @override */
  277. Sk.builtin.float_.prototype.nb$reflected_multiply = function (other) {
  278.     // Should not automatically call this.nb$multiply, as nb$multiply may have
  279.     // been overridden by a subclass
  280.     return Sk.builtin.float_.prototype.nb$multiply.call(this, other);
  281. };
  283. /** @override */
  284. Sk.builtin.float_.prototype.nb$divide = function (other) {
  285.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  287.         if (other.v === 0) {
  288.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  289.         }
  291.         if (this.v === Infinity) {
  292.             if (other.v === Infinity || other.v === -Infinity) {
  293.                 return new Sk.builtin.float_(NaN);
  294.             } else if (other.nb$isnegative()) {
  295.                 return new Sk.builtin.float_(-Infinity);
  296.             } else {
  297.                 return new Sk.builtin.float_(Infinity);
  298.             }
  299.         }
  300.         if (this.v === -Infinity) {
  301.             if (other.v === Infinity || other.v === -Infinity) {
  302.                 return new Sk.builtin.float_(NaN);
  303.             } else if (other.nb$isnegative()) {
  304.                 return new Sk.builtin.float_(Infinity);
  305.             } else {
  306.                 return new Sk.builtin.float_(-Infinity);
  307.             }
  308.         }
  310.         return new Sk.builtin.float_(this.v / other.v);
  311.     }
  313.     if (other instanceof Sk.builtin.lng) {
  314.         if (other.longCompare(Sk.builtin.biginteger.ZERO) === 0) {
  315.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  316.         }
  318.         if (this.v === Infinity) {
  319.             if (other.nb$isnegative()) {
  320.                 return new Sk.builtin.float_(-Infinity);
  321.             } else {
  322.                 return new Sk.builtin.float_(Infinity);
  323.             }
  324.         }
  325.         if (this.v === -Infinity) {
  326.             if (other.nb$isnegative()) {
  327.                 return new Sk.builtin.float_(Infinity);
  328.             } else {
  329.                 return new Sk.builtin.float_(-Infinity);
  330.             }
  331.         }
  333.         return new Sk.builtin.float_(this.v / parseFloat(other.str$(10, true)));
  334.     }
  336.     return Sk.builtin.NotImplemented.NotImplemented$;
  337. };
  339. /** @override */
  340. Sk.builtin.float_.prototype.nb$reflected_divide = function (other) {
  341.     if (other instanceof Sk.builtin.int_ ||
  342.         other instanceof Sk.builtin.lng) {
  343.         other = new Sk.builtin.float_(other);
  344.     }
  346.     if (other instanceof Sk.builtin.float_) {
  347.         return other.nb$divide(this);
  348.     }
  350.     return Sk.builtin.NotImplemented.NotImplemented$;
  351. };
  353. /** @override */
  354. Sk.builtin.float_.prototype.nb$floor_divide = function (other) {
  356.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  358.         if (this.v === Infinity || this.v === -Infinity) {
  359.             return new Sk.builtin.float_(NaN);
  360.         }
  362.         if (other.v === 0) {
  363.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  364.         }
  366.         if (other.v === Infinity) {
  367.             if (this.nb$isnegative()) {
  368.                 return new Sk.builtin.float_(-1);
  369.             } else {
  370.                 return new Sk.builtin.float_(0);
  371.             }
  372.         }
  373.         if (other.v === -Infinity) {
  374.             if (this.nb$isnegative() || !this.nb$nonzero()) {
  375.                 return new Sk.builtin.float_(0);
  376.             } else {
  377.                 return new Sk.builtin.float_(-1);
  378.             }
  379.         }
  381.         return new Sk.builtin.float_(Math.floor(this.v / other.v));
  382.     }
  384.     if (other instanceof Sk.builtin.lng) {
  385.         if (other.longCompare(Sk.builtin.biginteger.ZERO) === 0) {
  386.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  387.         }
  389.         if (this.v === Infinity || this.v === -Infinity) {
  390.             return new Sk.builtin.float_(NaN);
  391.         }
  393.         return new Sk.builtin.float_(Math.floor(this.v / parseFloat(other.str$(10, true))));
  394.     }
  396.     return Sk.builtin.NotImplemented.NotImplemented$;
  397. };
  399. /** @override */
  400. Sk.builtin.float_.prototype.nb$reflected_floor_divide = function (other) {
  401.     if (other instanceof Sk.builtin.int_ ||
  402.         other instanceof Sk.builtin.lng) {
  403.         other = new Sk.builtin.float_(other);
  404.     }
  406.     if (other instanceof Sk.builtin.float_) {
  407.         return other.nb$floor_divide(this);
  408.     }
  410.     return Sk.builtin.NotImplemented.NotImplemented$;
  411. };
  413. /** @override */
  414. Sk.builtin.float_.prototype.nb$remainder = function (other) {
  415.     var thisAsLong;
  416.     var op2;
  417.     var tmp;
  418.     var result;
  420.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  422.         if (other.v === 0) {
  423.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  424.         }
  426.         if (this.v === 0) {
  427.             return new Sk.builtin.float_(0);
  428.         }
  430.         if (other.v === Infinity) {
  431.             if (this.v === Infinity || this.v === -Infinity) {
  432.                 return new Sk.builtin.float_(NaN);
  433.             } else if (this.nb$ispositive()) {
  434.                 return new Sk.builtin.float_(this.v);
  435.             } else {
  436.                 return new Sk.builtin.float_(Infinity);
  437.             }
  438.         }
  440.         //  Javacript logic on negatives doesn't work for Python... do this instead
  441.         tmp = this.v % other.v;
  443.         if (this.v < 0) {
  444.             if (other.v > 0 && tmp < 0) {
  445.                 tmp = tmp + other.v;
  446.             }
  447.         } else {
  448.             if (other.v < 0 && tmp !== 0) {
  449.                 tmp = tmp + other.v;
  450.             }
  451.         }
  453.         if (other.v < 0 && tmp === 0) {
  454.             tmp = -0.0; // otherwise the sign gets lost by javascript modulo
  455.         } else if (tmp === 0 && Infinity/tmp === -Infinity) {
  456.             tmp = 0.0;
  457.         }
  459.         return new Sk.builtin.float_(tmp);
  460.     }
  462.     if (other instanceof Sk.builtin.lng) {
  463.         if (other.longCompare(Sk.builtin.biginteger.ZERO) === 0) {
  464.             throw new Sk.builtin.ZeroDivisionError("integer division or modulo by zero");
  465.         }
  467.         if (this.v === 0) {
  468.             return new Sk.builtin.float_(0);
  469.         }
  471.         op2 = parseFloat(other.str$(10, true));
  472.         tmp = this.v % op2;
  474.         if (tmp < 0) {
  475.             if (op2 > 0 && tmp !== 0) {
  476.                 tmp = tmp + op2;
  477.             }
  478.         } else {
  479.             if (op2 < 0 && tmp !== 0) {
  480.                 tmp = tmp + op2;
  481.             }
  482.         }
  484.         if (other.nb$isnegative() && tmp === 0) {
  485.             tmp = -0.0; // otherwise the sign gets lost by javascript modulo
  486.         } else if (tmp === 0 && Infinity/tmp === -Infinity) {
  487.             tmp = 0.0;
  488.         }
  490.         return new Sk.builtin.float_(tmp);
  491.     }
  493.     return Sk.builtin.NotImplemented.NotImplemented$;
  494. };
  496. /** @override */
  497. Sk.builtin.float_.prototype.nb$reflected_remainder = function (other) {
  498.     if (other instanceof Sk.builtin.int_ ||
  499.         other instanceof Sk.builtin.lng) {
  500.         other = new Sk.builtin.float_(other);
  501.     }
  503.     if (other instanceof Sk.builtin.float_) {
  504.         return other.nb$remainder(this);
  505.     }
  507.     return Sk.builtin.NotImplemented.NotImplemented$;
  508. };
  510. /** @override */
  511. Sk.builtin.float_.prototype.nb$divmod = function (other) {
  512.     if (other instanceof Sk.builtin.int_ ||
  513.         other instanceof Sk.builtin.lng) {
  514.         other = new Sk.builtin.float_(other);
  515.     }
  517.     if (other instanceof Sk.builtin.float_) {
  518.         return new Sk.builtin.tuple([
  519.             this.nb$floor_divide(other),
  520.             this.nb$remainder(other)
  521.         ]);
  522.     }
  524.     return Sk.builtin.NotImplemented.NotImplemented$;
  525. };
  527. /** @override */
  528. Sk.builtin.float_.prototype.nb$reflected_divmod = function (other) {
  529.     if (other instanceof Sk.builtin.int_ ||
  530.         other instanceof Sk.builtin.lng) {
  531.         other = new Sk.builtin.float_(other);
  532.     }
  534.     if (other instanceof Sk.builtin.float_) {
  535.         return new Sk.builtin.tuple([
  536.             other.nb$floor_divide(this),
  537.             other.nb$remainder(this)
  538.         ]);
  539.     }
  541.     return Sk.builtin.NotImplemented.NotImplemented$;
  542. };
  544. /** @override */
  545. Sk.builtin.float_.prototype.nb$power = function (other, mod) {
  546.     var thisAsLong;
  547.     var result;
  549.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  550.         if (this.v < 0 && other.v % 1 !== 0) {
  551.             throw new Sk.builtin.NegativePowerError("cannot raise a negative number to a fractional power");
  552.         }
  553.         if (this.v === 0 && other.v < 0) {
  554.             throw new Sk.builtin.NegativePowerError("cannot raise zero to a negative power");
  555.         }
  557.         result = new Sk.builtin.float_(Math.pow(this.v, other.v));
  559.         if ((Math.abs(result.v) === Infinity) &&
  560.             (Math.abs(this.v) !== Infinity) &&
  561.             (Math.abs(other.v) !== Infinity)) {
  562.             throw new Sk.builtin.OverflowError("Numerical result out of range");
  563.         }
  564.         return result;
  565.     }
  567.     if (other instanceof Sk.builtin.lng) {
  568.         if (this.v === 0 && other.longCompare(Sk.builtin.biginteger.ZERO) < 0) {
  569.             throw new Sk.builtin.NegativePowerError("cannot raise zero to a negative power");
  570.         }
  572.         return new Sk.builtin.float_(Math.pow(this.v, parseFloat(other.str$(10, true))));
  573.     }
  575.     return Sk.builtin.NotImplemented.NotImplemented$;
  576. };
  578. /** @override */
  579. Sk.builtin.float_.prototype.nb$reflected_power = function (n, mod) {
  580.     if (n instanceof Sk.builtin.int_ ||
  581.         n instanceof Sk.builtin.lng) {
  582.         n = new Sk.builtin.float_(n);
  583.     }
  585.     if (n instanceof Sk.builtin.float_) {
  586.         return n.nb$power(this, mod);
  587.     }
  589.     return Sk.builtin.NotImplemented.NotImplemented$;
  590. };
  592. /** @override */
  593. Sk.builtin.float_.prototype.nb$abs = function () {
  594.     return new Sk.builtin.float_(Math.abs(this.v));
  595. };
  597. /** @override */
  598. Sk.builtin.float_.prototype.nb$inplace_add = Sk.builtin.float_.prototype.nb$add;
  600. /** @override */
  601. Sk.builtin.float_.prototype.nb$inplace_subtract = Sk.builtin.float_.prototype.nb$subtract;
  603. /** @override */
  604. Sk.builtin.float_.prototype.nb$inplace_multiply = Sk.builtin.float_.prototype.nb$multiply;
  606. /** @override */
  607. Sk.builtin.float_.prototype.nb$inplace_divide = Sk.builtin.float_.prototype.nb$divide;
  609. /** @override */
  610. Sk.builtin.float_.prototype.nb$inplace_remainder = Sk.builtin.float_.prototype.nb$remainder;
  612. /** @override */
  613. Sk.builtin.float_.prototype.nb$inplace_floor_divide = Sk.builtin.float_.prototype.nb$floor_divide;
  615. /** @override */
  616. Sk.builtin.float_.prototype.nb$inplace_power = Sk.builtin.float_.prototype.nb$power;
  618. /**
  619.  * @override
  620.  *
  621.  * @return {Sk.builtin.float_} A copy of this instance with the value negated.
  622.  */
  623. Sk.builtin.float_.prototype.nb$negative = function () {
  624.     return new Sk.builtin.float_(-this.v);
  625. };
  627. /** @override */
  628. Sk.builtin.float_.prototype.nb$positive = function () {
  629.     return this.clone();
  630. };
  632. /** @override */
  633. Sk.builtin.float_.prototype.nb$nonzero = function () {
  634.     return this.v !== 0;
  635. };
  637. /** @override */
  638. Sk.builtin.float_.prototype.nb$isnegative = function () {
  639.     return this.v < 0;
  640. };
  642. /** @override */
  643. Sk.builtin.float_.prototype.nb$ispositive = function () {
  644.     return this.v >= 0;
  645. };
  647. /**
  648.  * Compare this instance's value to another Python object's value.
  649.  *
  650.  * Returns NotImplemented if comparison between float and other type is unsupported.
  651.  *
  652.  * Javscript function, returns Javascript object or Sk.builtin.NotImplemented.
  653.  *
  654.  * @return {(number|Sk.builtin.NotImplemented)} negative if this < other, zero if this == other, positive if this > other
  655.  */
  656. Sk.builtin.float_.prototype.numberCompare = function (other) {
  657.     var diff;
  658.     var tmp;
  659.     var thisAsLong;
  661.     if (other instanceof Sk.builtin.int_ || other instanceof Sk.builtin.float_) {
  662.         if (this.v == Infinity && other.v == Infinity) {
  663.             return 0;
  664.         }
  665.         if (this.v == -Infinity && other.v == -Infinity) {
  666.             return 0;
  667.         }
  668.         return this.v - other.v;
  669.     }
  671.     if (other instanceof Sk.builtin.lng) {
  672.         if (this.v % 1 === 0) {
  673.             thisAsLong = new Sk.builtin.lng(this.v);
  674.             tmp = thisAsLong.longCompare(other);
  675.             return tmp;
  676.         }
  677.         diff = this.nb$subtract(other);
  678.         if (diff instanceof Sk.builtin.float_) {
  679.             return diff.v;
  680.         } else if (diff instanceof Sk.builtin.lng) {
  681.             return diff.longCompare(Sk.builtin.biginteger.ZERO);
  682.         }
  683.     }
  685.     return Sk.builtin.NotImplemented.NotImplemented$;
  686. };
  688. // Despite what jshint may want us to do, these two  functions need to remain
  689. // as == and !=  Unless you modify the logic of numberCompare do not change
  690. // these.
  692. /** @override */
  693. Sk.builtin.float_.prototype.ob$eq = function (other) {
  694.     if (other instanceof Sk.builtin.int_ ||
  695.         other instanceof Sk.builtin.lng ||
  696.         other instanceof Sk.builtin.float_) {
  697.         return new Sk.builtin.bool(this.numberCompare(other) == 0); //jshint ignore:line
  698.     } else if (other instanceof Sk.builtin.none) {
  699.         return Sk.builtin.bool.false$;
  700.     } else {
  701.         return Sk.builtin.NotImplemented.NotImplemented$;
  702.     }
  703. };
  705. /** @override */
  706. Sk.builtin.float_.prototype.ob$ne = function (other) {
  707.     if (other instanceof Sk.builtin.int_ ||
  708.         other instanceof Sk.builtin.lng ||
  709.         other instanceof Sk.builtin.float_) {
  710.         return new Sk.builtin.bool(this.numberCompare(other) != 0); //jshint ignore:line
  711.     } else if (other instanceof Sk.builtin.none) {
  712.         return Sk.builtin.bool.true$;
  713.     } else {
  714.         return Sk.builtin.NotImplemented.NotImplemented$;
  715.     }
  716. };
  718. /** @override */
  719. Sk.builtin.float_.prototype.ob$lt = function (other) {
  720.     if (other instanceof Sk.builtin.int_ ||
  721.         other instanceof Sk.builtin.lng ||
  722.         other instanceof Sk.builtin.float_) {
  723.         return new Sk.builtin.bool(this.numberCompare(other) < 0);
  724.     } else {
  725.         return Sk.builtin.NotImplemented.NotImplemented$;
  726.     }
  727. };
  729. /** @override */
  730. Sk.builtin.float_.prototype.ob$le = function (other) {
  731.     if (other instanceof Sk.builtin.int_ ||
  732.         other instanceof Sk.builtin.lng ||
  733.         other instanceof Sk.builtin.float_) {
  734.         return new Sk.builtin.bool(this.numberCompare(other) <= 0);
  735.     } else {
  736.         return Sk.builtin.NotImplemented.NotImplemented$;
  737.     }
  738. };
  740. /** @override */
  741. Sk.builtin.float_.prototype.ob$gt = function (other) {
  742.     if (other instanceof Sk.builtin.int_ ||
  743.         other instanceof Sk.builtin.lng ||
  744.         other instanceof Sk.builtin.float_) {
  745.         return new Sk.builtin.bool(this.numberCompare(other) > 0);
  746.     } else {
  747.         return Sk.builtin.NotImplemented.NotImplemented$;
  748.     }
  749. };
  751. /** @override */
  752. Sk.builtin.float_.prototype.ob$ge = function (other) {
  753.     if (other instanceof Sk.builtin.int_ ||
  754.         other instanceof Sk.builtin.lng ||
  755.         other instanceof Sk.builtin.float_) {
  756.         return new Sk.builtin.bool(this.numberCompare(other) >= 0);
  757.     } else {
  758.         return Sk.builtin.NotImplemented.NotImplemented$;
  759.     }
  760. };
  762. /**
  763.  * Round this instance to a given number of digits, or zero if omitted.
  764.  *
  765.  * Implements `__round__` dunder method.
  766.  *
  767.  * Javascript function, returns Python object.
  768.  *
  769.  * @param  {Sk.builtin.int_} self This instance.
  770.  * @param  {Object|number=} ndigits The number of digits after the decimal point to which to round.
  771.  * @return {Sk.builtin.float_|Sk.builtin.int_} The rounded float.
  772.  */
  773. Sk.builtin.float_.prototype.round$ = function (self, ndigits) {
  774.     Sk.builtin.pyCheckArgsLen("__round__", arguments.length, 1, 2);
  776.     var result, multiplier, number, num10, rounded, bankRound, ndigs;
  778.     if ((ndigits !== undefined) && !Sk.misceval.isIndex(ndigits)) {
  779.         throw new Sk.builtin.TypeError("'" + Sk.abstr.typeName(ndigits) + "' object cannot be interpreted as an index");
  780.     }
  782.     number = Sk.builtin.asnum$(self);
  783.     if (ndigits === undefined) {
  784.         ndigs = 0;
  785.     } else {
  786.         ndigs = Sk.misceval.asIndex(ndigits);
  787.     }
  789.     if (Sk.__future__.bankers_rounding) {
  790.         num10 = number * Math.pow(10, ndigs);
  791.         rounded = Math.round(num10);
  792.         bankRound = (((((num10>0)?num10:(-num10))%1)===0.5)?(((0===(rounded%2)))?rounded:(rounded-1)):rounded);
  793.         result = bankRound / Math.pow(10, ndigs);
  794.         if (ndigits === undefined) {
  795.             return new Sk.builtin.int_(result);
  796.         } else {
  797.             return new Sk.builtin.float_(result);
  798.         }
  799.     } else {
  800.         multiplier = Math.pow(10, ndigs);
  801.         result = Math.round(number * multiplier) / multiplier;
  803.         return new Sk.builtin.float_(result);
  804.     }
  805. };
  807. Sk.builtin.float_.prototype.__format__= function (obj, format_spec) {
  808.     var formatstr;
  809.     Sk.builtin.pyCheckArgsLen("__format__", arguments.length, 2, 2);
  811.     if (!Sk.builtin.checkString(format_spec)) {
  812.         if (Sk.__future__.exceptions) {
  813.             throw new Sk.builtin.TypeError("format() argument 2 must be str, not " + Sk.abstr.typeName(format_spec));
  814.         } else {
  815.             throw new Sk.builtin.TypeError("format expects arg 2 to be string or unicode, not " + Sk.abstr.typeName(format_spec));
  816.         }
  817.     } else {
  818.         formatstr = Sk.ffi.remapToJs(format_spec);
  819.         if (formatstr !== "") {
  820.             throw new Sk.builtin.NotImplementedError("format spec is not yet implemented");
  821.         }
  822.     }
  824.     return new Sk.builtin.str(obj);
  825. };
  828. Sk.builtin.float_.prototype.conjugate = new Sk.builtin.func(function (self) {
  829.     return new Sk.builtin.float_(self.v);
  830. });
  832. /** @override */
  833. Sk.builtin.float_.prototype["$r"] = function () {
  834.     return new Sk.builtin.str(this.str$(10, true));
  835. };
  837. /**
  838.  * Return the string representation of this instance.
  839.  *
  840.  * Javascript function, returns Python object.
  841.  *
  842.  * @return {Sk.builtin.str} The Python string representation of this instance.
  843.  */
  844. Sk.builtin.float_.prototype.tp$str = function () {
  845.     return new Sk.builtin.str(this.str$(10, true));
  846. };
  848. /**
  849.  * Convert this instance's value to a Javascript string.
  850.  *
  851.  * Javascript function, returns Javascript object.
  852.  *
  853.  * @param {number} base The base of the value.
  854.  * @param {boolean} sign true if the value should be signed, false otherwise.
  855.  * @return {string} The Javascript string representation of this instance.
  856.  */
  857. Sk.builtin.float_.prototype.str$ = function (base, sign) {
  858.     var post;
  859.     var pre;
  860.     var idx;
  861.     var tmp;
  862.     var work;
  864.     if (isNaN(this.v)) {
  865.         return "nan";
  866.     }
  868.     if (sign === undefined) {
  869.         sign = true;
  870.     }
  872.     if (this.v == Infinity) {
  873.         return "inf";
  874.     }
  875.     if (this.v == -Infinity && sign) {
  876.         return "-inf";
  877.     }
  878.     if (this.v == -Infinity && !sign) {
  879.         return "inf";
  880.     }
  882.     work = sign ? this.v : Math.abs(this.v);
  885.     if (base === undefined || base === 10) {
  886.         tmp = work.toPrecision(12);
  888.         // transform fractions with 4 or more leading zeroes into exponents
  889.         idx = tmp.indexOf(".");
  890.         pre = work.toString().slice(0, idx);
  891.         post = work.toString().slice(idx);
  893.         if (pre.match(/^-?0$/) && post.slice(1).match(/^0{4,}/)) {
  894.             if (tmp.length < 12) {
  895.                 tmp = work.toExponential();
  896.             } else {
  897.                 tmp = work.toExponential(11);
  898.             }
  899.         }
  901.         if (tmp.indexOf("e") < 0 && tmp.indexOf(".") >= 0) {
  902.             while (tmp.charAt(tmp.length-1) == "0") {
  903.                 tmp = tmp.substring(0,tmp.length-1);
  904.             }
  905.             if (tmp.charAt(tmp.length-1) == ".") {
  906.                 tmp = tmp + "0";
  907.             }
  908.         }
  910.         tmp = tmp.replace(new RegExp("\\.0+e"), "e", "i");
  911.         // make exponent two digits instead of one (ie e+09 not e+9)
  912.         tmp = tmp.replace(/(e[-+])([1-9])$/, "$10$2");
  913.         // remove trailing zeroes before the exponent
  914.         tmp = tmp.replace(/0+(e.*)/, "$1");
  915.     } else {
  916.         tmp = work.toString(base);
  917.     }
  919.     // restore negative zero sign
  920.     if(this.v === 0 && 1/this.v === -Infinity) {
  921.         tmp = "-" + tmp;
  922.     }
  924.     if (tmp.indexOf(".") < 0 && tmp.indexOf("E") < 0 && tmp.indexOf("e") < 0) {
  925.         tmp = tmp + ".0";
  926.     }
  928.     return tmp;
  929. };