Class: Number

Inherits:

Numeric

• Object
• Numeric
• Number

Defined in:

opal/opal/corelib/number.rb

Class Method Summary

• .allocate ⇒ Object

Instance Method Summary

• #%(other) ⇒ Object (also: #modulo)
• #&(other) ⇒ Object
• #*(other) ⇒ Object
• #**(other) ⇒ Object
• #+(other) ⇒ Object
• #+@ ⇒ Object
• #-(other) ⇒ Object
• #-@ ⇒ Object
• #/(other) ⇒ Object (also: #fdiv)
• #<(other) ⇒ Object
• #<<(count) ⇒ Object
• #<=(other) ⇒ Object
• #<=>(other) ⇒ Object
• #==(other) ⇒ Object (also: #===, #eql?)
• #>(other) ⇒ Object
• #>=(other) ⇒ Object
• #>>(count) ⇒ Object
• #[](bit) ⇒ Object
• #^(other) ⇒ Object
• #__id__ ⇒ Object (also: #object_id)
• #abs ⇒ Object (also: #magnitude)
• #abs2 ⇒ Object
• #allbits?(mask) ⇒ Boolean
• #angle ⇒ Object (also: #arg, #phase)
• #anybits?(mask) ⇒ Boolean
• #bit_length ⇒ Object
• #ceil(ndigits = 0) ⇒ Object
• #chr(encoding = undefined) ⇒ Object
• #coerce(other) ⇒ Object
• #denominator ⇒ Object
• #digits(base = 10) ⇒ Object
• #divmod(other) ⇒ Object
• #downto(stop, &block) ⇒ Object
• #equal?(other) ⇒ Boolean
• #even? ⇒ Boolean
• #finite? ⇒ Boolean
• #floor(ndigits = 0) ⇒ Object
• #gcd(other) ⇒ Object
• #gcdlcm(other) ⇒ Object
• #infinite? ⇒ Boolean
• #instance_of?(klass) ⇒ Boolean
• #integer? ⇒ Boolean
• #is_a?(klass) ⇒ Boolean (also: #kind_of?)
• #lcm(other) ⇒ Object
• #nan? ⇒ Boolean
• #negative? ⇒ Boolean
• #next ⇒ Object (also: #succ)
• #next_float ⇒ Object
• #nobits?(mask) ⇒ Boolean
• #nonzero? ⇒ Boolean
• #numerator ⇒ Object
• #odd? ⇒ Boolean
• #ord ⇒ Object
• #positive? ⇒ Boolean
• #pow(b, m = undefined) ⇒ Object
• #pred ⇒ Object
• #prev_float ⇒ Object
• #quo(other) ⇒ Object
• #rationalize(eps = undefined) ⇒ Object
• #remainder(y) ⇒ Object
• #round(ndigits = undefined) ⇒ Object
• #size ⇒ Object

  Since bitwise operations are 32 bit, declare it to be so.

• #times(&block) ⇒ Object
• #to_f ⇒ Object
• #to_i ⇒ Object (also: #to_int)
• #to_r ⇒ Object
• #to_s(base = 10) ⇒ Object (also: #inspect)
• #truncate(ndigits = 0) ⇒ Object
• #upto(stop, &block) ⇒ Object
• #zero? ⇒ Boolean
• #|(other) ⇒ Object
• #~ ⇒ Object

Methods inherited from Numeric

#__coerced__, #clone, #conj, #div, #dup, #i, #imag, #polar, #real, #real?, #rect, #step, #to_c

Methods included from Comparable

#between?, #clamp

Class Method Details

.allocate ⇒ Object

# File 'opal/opal/corelib/number.rb', line 9

def allocate
  ::Kernel.raise ::TypeError, "allocator undefined for #{name}"
end

Instance Method Details

#%(other) ⇒ Object Also known as: modulo

# File 'opal/opal/corelib/number.rb', line 84

def %(other)
  %x{
    if (other.$$is_number) {
      if (other == -Infinity) {
        return other;
      }
      else if (other == 0) {
        #{::Kernel.raise ::ZeroDivisionError, 'divided by 0'};
      }
      else if (other < 0 || self < 0) {
        return (self % other + other) % other;
      }
      else {
        return self % other;
      }
    }
    else {
      return #{__coerced__ :%, other};
    }
  }
end

#&(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 106

def &(other)
  %x{
    if (other.$$is_number) {
      return self & other;
    }
    else {
      return #{__coerced__ :&, other};
    }
  }
end

#*(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 62

def *(other)
  %x{
    if (other.$$is_number) {
      return self * other;
    }
    else {
      return #{__coerced__ :*, other};
    }
  }
end

#**(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 250

def **(other)
  if ::Integer === other
    if !(::Integer === self) || other > 0
      `Math.pow(self, other)`
    else
      ::Rational.new(self, 1)**other
    end
  elsif self < 0 && (::Float === other || ::Rational === other)
    ::Complex.new(self, 0)**other.to_f
  elsif `other.$$is_number != null`
    `Math.pow(self, other)`
  else
    __coerced__ :**, other
  end
end

#+(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 40

def +(other)
  %x{
    if (other.$$is_number) {
      return self + other;
    }
    else {
      return #{__coerced__ :+, other};
    }
  }
end

#+@ ⇒ Object

# File 'opal/opal/corelib/number.rb', line 238

def +@
  `+self`
end

#-(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 51

def -(other)
  %x{
    if (other.$$is_number) {
      return self - other;
    }
    else {
      return #{__coerced__ :-, other};
    }
  }
end

#-@ ⇒ Object

# File 'opal/opal/corelib/number.rb', line 242

def -@
  `-self`
end

#/(other) ⇒ Object Also known as: fdiv

# File 'opal/opal/corelib/number.rb', line 73

def /(other)
  %x{
    if (other.$$is_number) {
      return self / other;
    }
    else {
      return #{__coerced__ :/, other};
    }
  }
end

#<(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 139

def <(other)
  %x{
    if (other.$$is_number) {
      return self < other;
    }
    else {
      return #{__coerced__ :<, other};
    }
  }
end

#<<(count) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 212

def <<(count)
  count = ::Opal.coerce_to! count, ::Integer, :to_int

  `#{count} > 0 ? self << #{count} : self >> -#{count}`
end

#<=(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 150

def <=(other)
  %x{
    if (other.$$is_number) {
      return self <= other;
    }
    else {
      return #{__coerced__ :<=, other};
    }
  }
end

#<=>(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 206

def <=>(other)
  `spaceship_operator(self, other)`
rescue ::ArgumentError
  nil
end

#==(other) ⇒ Object Also known as: ===, eql?

# File 'opal/opal/corelib/number.rb', line 266

def ==(other)
  %x{
    if (other.$$is_number) {
      return self.valueOf() === other.valueOf();
    }
    else if (#{other.respond_to? :==}) {
      return #{other == self};
    }
    else {
      return false;
    }
  }
end

#>(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 161

def >(other)
  %x{
    if (other.$$is_number) {
      return self > other;
    }
    else {
      return #{__coerced__ :>, other};
    }
  }
end

#>=(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 172

def >=(other)
  %x{
    if (other.$$is_number) {
      return self >= other;
    }
    else {
      return #{__coerced__ :>=, other};
    }
  }
end

#>>(count) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 218

def >>(count)
  count = ::Opal.coerce_to! count, ::Integer, :to_int

  `#{count} > 0 ? self >> #{count} : self << -#{count}`
end

#[](bit) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 224

def [](bit)
  bit = ::Opal.coerce_to! bit, ::Integer, :to_int

  %x{
    if (#{bit} < 0) {
      return 0;
    }
    if (#{bit} >= 32) {
      return #{ self } < 0 ? 1 : 0;
    }
    return (self >> #{bit}) & 1;
  }
end

#^(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 128

def ^(other)
  %x{
    if (other.$$is_number) {
      return self ^ other;
    }
    else {
      return #{__coerced__ :^, other};
    }
  }
end

#__id__ ⇒ Object Also known as: object_id

# File 'opal/opal/corelib/number.rb', line 36

def __id__
  `(self * 2) + 1`
end

#abs ⇒ Object Also known as: magnitude

# File 'opal/opal/corelib/number.rb', line 282

def abs
  `Math.abs(self)`
end

#abs2 ⇒ Object

# File 'opal/opal/corelib/number.rb', line 286

def abs2
  `Math.abs(self * self)`
end

#allbits?(mask) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 290

def allbits?(mask)
  mask = ::Opal.coerce_to! mask, ::Integer, :to_int
  `(self & mask) == mask`
end

#angle ⇒ Object Also known as: arg, phase

# File 'opal/opal/corelib/number.rb', line 300

def angle
  return self if nan?

  %x{
    if (self == 0) {
      if (1 / self > 0) {
        return 0;
      }
      else {
        return Math.PI;
      }
    }
    else if (self < 0) {
      return Math.PI;
    }
    else {
      return 0;
    }
  }
end

#anybits?(mask) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 295

def anybits?(mask)
  mask = ::Opal.coerce_to! mask, ::Integer, :to_int
  `(self & mask) !== 0`
end

#bit_length ⇒ Object

# File 'opal/opal/corelib/number.rb', line 321

def bit_length
  unless ::Integer === self
    ::Kernel.raise ::NoMethodError.new("undefined method `bit_length` for #{self}:Float", 'bit_length')
  end

  %x{
    if (self === 0 || self === -1) {
      return 0;
    }

    var result = 0,
        value  = self < 0 ? ~self : self;

    while (value != 0) {
      result   += 1;
      value  >>>= 1;
    }

    return result;
  }
end

#ceil(ndigits = 0) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 343

def ceil(ndigits = 0)
  %x{
    var f = #{to_f};

    if (f % 1 === 0 && ndigits >= 0) {
      return f;
    }

    var factor = Math.pow(10, ndigits),
        result = Math.ceil(f * factor) / factor;

    if (f % 1 === 0) {
      result = Math.round(result);
    }

    return result;
  }
end

#chr(encoding = undefined) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 362

def chr(encoding = undefined)
  `Opal.enc(String.fromCharCode(self), encoding || "BINARY")`
end

#coerce(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 16

def coerce(other)
  %x{
    if (other === nil) {
      #{::Kernel.raise ::TypeError, "can't convert #{other.class} into Float"};
    }
    else if (other.$$is_string) {
      return [#{::Kernel.Float(other)}, self];
    }
    else if (#{other.respond_to?(:to_f)}) {
      return [#{::Opal.coerce_to!(other, ::Float, :to_f)}, self];
    }
    else if (other.$$is_number) {
      return [other, self];
    }
    else {
      #{::Kernel.raise ::TypeError, "can't convert #{other.class} into Float"};
    }
  }
end

#denominator ⇒ Object

# File 'opal/opal/corelib/number.rb', line 366

def denominator
  if nan? || infinite?
    1
  else
    super
  end
end

#digits(base = 10) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 710

def digits(base = 10)
  if self < 0
    ::Kernel.raise ::Math::DomainError, 'out of domain'
  end

  base = ::Opal.coerce_to! base, ::Integer, :to_int

  if base < 2
    ::Kernel.raise ::ArgumentError, "invalid radix #{base}"
  end

  %x{
    if (self != parseInt(self)) #{::Kernel.raise ::NoMethodError, "undefined method `digits' for #{inspect}"}

    var value = self, result = [];

    if (self == 0) {
      return [0];
    }

    while (value != 0) {
      result.push(value % base);
      value = parseInt(value / base, 10);
    }

    return result;
  }
end

#divmod(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 739

def divmod(other)
  if nan? || other.nan?
    ::Kernel.raise ::FloatDomainError, 'NaN'
  elsif infinite?
    ::Kernel.raise ::FloatDomainError, 'Infinity'
  else
    super
  end
end

#downto(stop, &block) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 374

def downto(stop, &block)
  unless block_given?
    return enum_for(:downto, stop) do
      ::Kernel.raise ::ArgumentError, "comparison of #{self.class} with #{stop.class} failed" unless ::Numeric === stop
      stop > self ? 0 : self - stop + 1
    end
  end

  %x{
    if (!stop.$$is_number) {
      #{::Kernel.raise ::ArgumentError, "comparison of #{self.class} with #{stop.class} failed"}
    }
    for (var i = self; i >= stop; i--) {
      block(i);
    }
  }

  self
end

#equal?(other) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 394

def equal?(other)
  self == other || `isNaN(self) && isNaN(other)`
end

#even? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 398

def even?
  `self % 2 === 0`
end

#finite? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 782

def finite?
  `self != Infinity && self != -Infinity && !isNaN(self)`
end

#floor(ndigits = 0) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 402

def floor(ndigits = 0)
  %x{
    var f = #{to_f};

    if (f % 1 === 0 && ndigits >= 0) {
      return f;
    }

    var factor = Math.pow(10, ndigits),
        result = Math.floor(f * factor) / factor;

    if (f % 1 === 0) {
      result = Math.round(result);
    }

    return result;
  }
end

#gcd(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 421

def gcd(other)
  unless ::Integer === other
    ::Kernel.raise ::TypeError, 'not an integer'
  end

  %x{
    var min = Math.abs(self),
        max = Math.abs(other);

    while (min > 0) {
      var tmp = min;

      min = max % min;
      max = tmp;
    }

    return max;
  }
end

#gcdlcm(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 441

def gcdlcm(other)
  [gcd(other), lcm(other)]
end

#infinite? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 786

def infinite?
  %x{
    if (self == Infinity) {
      return +1;
    }
    else if (self == -Infinity) {
      return -1;
    }
    else {
      return nil;
    }
  }
end

#instance_of?(klass) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 457

def instance_of?(klass)
  return true if klass == ::Integer && ::Integer === self
  return true if klass == ::Integer && ::Integer === self
  return true if klass == ::Float && ::Float === self

  super
end

#integer? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 445

def integer?
  `self % 1 === 0`
end

#is_a?(klass) ⇒ Boolean Also known as: kind_of?

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 449

def is_a?(klass)
  return true if klass == ::Integer && ::Integer === self
  return true if klass == ::Integer && ::Integer === self
  return true if klass == ::Float && ::Float === self

  super
end

#lcm(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 465

def lcm(other)
  unless ::Integer === other
    ::Kernel.raise ::TypeError, 'not an integer'
  end

  %x{
    if (self == 0 || other == 0) {
      return 0;
    }
    else {
      return Math.abs(self * other / #{gcd(other)});
    }
  }
end

#nan? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 778

def nan?
  `isNaN(self)`
end

#negative? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 804

def negative?
  `self == -Infinity || 1 / self < 0`
end

#next ⇒ Object Also known as: succ

# File 'opal/opal/corelib/number.rb', line 480

def next
  `self + 1`
end

#next_float ⇒ Object

# File 'opal/opal/corelib/number.rb', line 846

def next_float
  return ::Float::INFINITY if self == ::Float::INFINITY
  return ::Float::NAN if nan?

  if self >= 0
    # Math.abs() is needed to handle -0.0
    `incrementNumberBit(Math.abs(self))`
  else
    `decrementNumberBit(self)`
  end
end

#nobits?(mask) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 484

def nobits?(mask)
  mask = ::Opal.coerce_to! mask, ::Integer, :to_int
  `(self & mask) == 0`
end

#nonzero? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 489

def nonzero?
  `self == 0 ? nil : self`
end

#numerator ⇒ Object

# File 'opal/opal/corelib/number.rb', line 493

def numerator
  if nan? || infinite?
    self
  else
    super
  end
end

#odd? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 501

def odd?
  `self % 2 !== 0`
end

#ord ⇒ Object

# File 'opal/opal/corelib/number.rb', line 505

def ord
  self
end

#positive? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 800

def positive?
  `self != 0 && (self == Infinity || 1 / self > 0)`
end

#pow(b, m = undefined) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 509

def pow(b, m = undefined)
  %x{
    if (self == 0) {
      #{::Kernel.raise ::ZeroDivisionError, 'divided by 0'}
    }

    if (m === undefined) {
      return #{self**b};
    } else {
      if (!(#{::Integer === b})) {
        #{::Kernel.raise ::TypeError, 'Integer#pow() 2nd argument not allowed unless a 1st argument is integer'}
      }

      if (b < 0) {
        #{::Kernel.raise ::TypeError, 'Integer#pow() 1st argument cannot be negative when 2nd argument specified'}
      }

      if (!(#{::Integer === m})) {
        #{::Kernel.raise ::TypeError, 'Integer#pow() 2nd argument not allowed unless all arguments are integers'}
      }

      if (m === 0) {
        #{::Kernel.raise ::ZeroDivisionError, 'divided by 0'}
      }

      return #{(self**b) % m}
    }
  }
end

#pred ⇒ Object

# File 'opal/opal/corelib/number.rb', line 539

def pred
  `self - 1`
end

#prev_float ⇒ Object

# File 'opal/opal/corelib/number.rb', line 858

def prev_float
  return -::Float::INFINITY if self == -::Float::INFINITY
  return ::Float::NAN if nan?

  if self > 0
    `decrementNumberBit(self)`
  else
    `-incrementNumberBit(Math.abs(self))`
  end
end

#quo(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 543

def quo(other)
  if ::Integer === self
    super
  else
    self / other
  end
end

#rationalize(eps = undefined) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 551

def rationalize(eps = undefined)
  %x{
    if (arguments.length > 1) {
      #{::Kernel.raise ::ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..1)"};
    }
  }

  if ::Integer === self
    ::Rational.new(self, 1)
  elsif infinite?
    ::Kernel.raise ::FloatDomainError, 'Infinity'
  elsif nan?
    ::Kernel.raise ::FloatDomainError, 'NaN'
  elsif `eps == null`
    f, n  = ::Math.frexp self
    f     = ::Math.ldexp(f, ::Float::MANT_DIG).to_i
    n    -= ::Float::MANT_DIG

    ::Rational.new(2 * f, 1 << (1 - n)).rationalize(::Rational.new(1, 1 << (1 - n)))
  else
    to_r.rationalize(eps)
  end
end

#remainder(y) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 575

def remainder(y)
  self - y * (self / y).truncate
end

#round(ndigits = undefined) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 579

def round(ndigits = undefined)
  if ::Integer === self
    if `ndigits == null`
      return self
    end

    if ::Float === ndigits && ndigits.infinite?
      ::Kernel.raise ::RangeError, 'Infinity'
    end

    ndigits = ::Opal.coerce_to!(ndigits, ::Integer, :to_int)

    if ndigits < ::Integer::MIN
      ::Kernel.raise ::RangeError, 'out of bounds'
    end

    if `ndigits >= 0`
      return self
    end

    ndigits = -ndigits

    %x{
      if (0.415241 * ndigits - 0.125 > #{size}) {
        return 0;
      }

      var f = Math.pow(10, ndigits),
          x = Math.floor((Math.abs(self) + f / 2) / f) * f;

      return self < 0 ? -x : x;
    }
  else
    if nan? && `ndigits == null`
      ::Kernel.raise ::FloatDomainError, 'NaN'
    end

    ndigits = ::Opal.coerce_to!(`ndigits || 0`, ::Integer, :to_int)

    if ndigits <= 0
      if nan?
        ::Kernel.raise ::RangeError, 'NaN'
      elsif infinite?
        ::Kernel.raise ::FloatDomainError, 'Infinity'
      end
    elsif ndigits == 0
      return `Math.round(self)`
    elsif nan? || infinite?
      return self
    end

    _, exp = ::Math.frexp(self)

    if ndigits >= (::Float::DIG + 2) - (exp > 0 ? exp / 4 : exp / 3 - 1)
      return self
    end

    if ndigits < -(exp > 0 ? exp / 3 + 1 : exp / 4)
      return 0
    end

    `Math.round(self * Math.pow(10, ndigits)) / Math.pow(10, ndigits)`
  end
end

#size ⇒ Object

Since bitwise operations are 32 bit, declare it to be so.

# File 'opal/opal/corelib/number.rb', line 774

def size
  4
end

#times(&block) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 644

def times(&block)
  return enum_for(:times) { self } unless block

  %x{
    for (var i = 0; i < self; i++) {
      block(i);
    }
  }

  self
end

#to_f ⇒ Object

# File 'opal/opal/corelib/number.rb', line 656

def to_f
  self
end

#to_i ⇒ Object Also known as: to_int

# File 'opal/opal/corelib/number.rb', line 660

def to_i
  `self < 0 ? Math.ceil(self) : Math.floor(self)`
end

#to_r ⇒ Object

# File 'opal/opal/corelib/number.rb', line 664

def to_r
  if ::Integer === self
    ::Rational.new(self, 1)
  else
    f, e  = ::Math.frexp(self)
    f     = ::Math.ldexp(f, ::Float::MANT_DIG).to_i
    e    -= ::Float::MANT_DIG

    (f * (::Float::RADIX**e)).to_r
  end
end

#to_s(base = 10) ⇒ Object Also known as: inspect

# File 'opal/opal/corelib/number.rb', line 676

def to_s(base = 10)
  base = ::Opal.coerce_to! base, ::Integer, :to_int

  if base < 2 || base > 36
    ::Kernel.raise ::ArgumentError, "invalid radix #{base}"
  end

  # Don't lose the negative zero
  if self == 0 && `1/self === -Infinity`
    return '-0.0'
  end

  `self.toString(base)`
end

#truncate(ndigits = 0) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 691

def truncate(ndigits = 0)
  %x{
    var f = #{to_f};

    if (f % 1 === 0 && ndigits >= 0) {
      return f;
    }

    var factor = Math.pow(10, ndigits),
        result = parseInt(f * factor, 10) / factor;

    if (f % 1 === 0) {
      result = Math.round(result);
    }

    return result;
  }
end

#upto(stop, &block) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 749

def upto(stop, &block)
  unless block_given?
    return enum_for(:upto, stop) do
      ::Kernel.raise ::ArgumentError, "comparison of #{self.class} with #{stop.class} failed" unless ::Numeric === stop
      stop < self ? 0 : stop - self + 1
    end
  end

  %x{
    if (!stop.$$is_number) {
      #{::Kernel.raise ::ArgumentError, "comparison of #{self.class} with #{stop.class} failed"}
    }
    for (var i = self; i <= stop; i++) {
      block(i);
    }
  }

  self
end

#zero? ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/number.rb', line 769

def zero?
  `self == 0`
end

#|(other) ⇒ Object

# File 'opal/opal/corelib/number.rb', line 117

def |(other)
  %x{
    if (other.$$is_number) {
      return self | other;
    }
    else {
      return #{__coerced__ :|, other};
    }
  }
end

#~ ⇒ Object

# File 'opal/opal/corelib/number.rb', line 246

def ~
  `~self`
end