[GR-14962] 26 numeric specs.

PullRequest: truffleruby/684

Author: eregon

CHANGELOG.md

@@ -3,6 +3,11 @@
 Bug fixes:
 
 * Sharing for thread-safety of objects is now triggered later as intended, e.g., when a second `Thread` is started.
+Compatibility:
+
+* Exceptions from `coerce` are no longer rescued, like MRI.
+* Implemented `Integer#{allbits?,anybits?,nobits?}`.
+* `Integer#{ceil,floor,truncate}` now accept a precision and `Integer#round` accepts a rounding mode.
 
 # 20.0.0 beta 1
 

spec/ruby/core/integer/round_spec.rb

@@ -67,12 +67,15 @@
     25.round(-1, half: :up).should      eql(30)
     25.round(-1, half: :down).should    eql(20)
     25.round(-1, half: :even).should    eql(20)
+    25.round(-1, half: nil).should      eql(30)
     35.round(-1, half: :up).should      eql(40)
     35.round(-1, half: :down).should    eql(30)
     35.round(-1, half: :even).should    eql(40)
+    35.round(-1, half: nil).should      eql(40)
     (-25).round(-1, half: :up).should   eql(-30)
     (-25).round(-1, half: :down).should eql(-20)
     (-25).round(-1, half: :even).should eql(-20)
+    (-25).round(-1, half: nil).should   eql(-30)
   end
 
   ruby_version_is "2.4"..."2.5" do
@@ -90,4 +93,9 @@
       35.round(1, half: :even).should    eql(35)
     end
   end
+
+  it "raises ArgumentError for an unknown rounding mode" do
+    lambda { 42.round(-1, half: :foo) }.should raise_error(ArgumentError, /invalid rounding mode: foo/)
+    lambda { 42.round(1, half: :foo) }.should raise_error(ArgumentError, /invalid rounding mode: foo/)
+  end
 end

spec/tags/core/float/divide_tags.txt

@@ -1742,17 +1742,23 @@ public Object pow(DynamicObject a, long b,
         }
 
         @Specialization
-        public double pow(DynamicObject a, double b) {
-            return powBigIntegerDouble(Layouts.BIGNUM.getValue(a), b);
+        public Object pow(DynamicObject a, double b) {
+            double doublePow = powBigIntegerDouble(Layouts.BIGNUM.getValue(a), b);
+            if (Double.isNaN(doublePow)) {
+                // Instead of returning NaN, run the fallback code which can create a complex result
+                return FAILURE;
+            } else {
+                return doublePow;
+            }
         }
 
         @Specialization(guards = "isRubyBignum(b)")
-        public Void pow(DynamicObject a, DynamicObject b) {
-            throw new UnsupportedOperationException();
+        public Object pow(DynamicObject a, DynamicObject b) {
+            return FAILURE;
         }
 
         @Specialization(guards = { "!isInteger(b)", "!isLong(b)", "!isDouble(b)", "!isRubyBignum(b)" })
-        public Object pow(long a, Object b) {
+        public Object pow(Object a, Object b) {
             return FAILURE;
         }
 

spec/tags/core/float/gt_tags.txt

@@ -39,20 +39,18 @@
 
 class Integer < Numeric
 
-  alias_method :truncate, :to_i
-  alias_method :ceil, :to_i
-  alias_method :floor, :to_i
-
   # Have a copy in Integer of the Numeric version, as MRI does
   public :remainder
 
   def **(o)
     Truffle.primitive :integer_pow
 
-    if o.is_a?(Float) && self < 0 && o != o.round
+    if (o.is_a?(Float) || o.is_a?(Rational)) && self < 0 && o != o.round
       return Complex.new(self, 0) ** o
     elsif o.is_a?(Integer) && o < 0
       return Rational.new(self, 1) ** o
+    elsif o.is_a?(Integer) && o > 0
+      return self ** o.to_f
     end
 
     redo_coerced :**, o
@@ -63,6 +61,22 @@ def [](index)
     index < 0 ? 0 : (self >> index) & 1
   end
 
+  def allbits?(mask)
+    mask = Truffle::Type.coerce_to_int(mask)
+    (self & mask) == mask
+  end
+
+  def anybits?(mask)
+    mask = Truffle::Type.coerce_to_int(mask)
+    (self & mask) != 0
+  end
+
+  def ceil(precision = 0)
+    return self unless precision < 0
+    x = 10 ** precision.abs
+    ((self / x) + 1) * x
+  end
+
   def coerce(other)
     if other.kind_of? Integer
       return [other, self]
@@ -88,6 +102,23 @@ def fdiv(n)
     end
   end
 
+  def floor(precision = 0)
+    return self unless precision < 0
+    x = 10 ** precision.abs
+    (self / x) * x
+  end
+
+  def nobits?(mask)
+    mask = Truffle::Type.coerce_to_int(mask)
+    (self & mask) == 0
+  end
+
+  def pow(e, m=undefined)
+    return self ** e if undefined.equal?(m)
+    raise TypeError, '2nd argument not allowed unless all arguments are integers' unless Truffle::Type.object_kind_of?(m, Integer)
+    (self ** e) % m
+  end
+
   def times
     return to_enum(:times) { self } unless block_given?
 
@@ -99,6 +130,14 @@ def times
     self
   end
 
+  def truncate(precision = 0)
+    if precision >= 0
+      self
+    else
+      round(precision, half: :down)
+    end
+  end
+
   def chr(enc=undefined)
     if self < 0 || (self & 0xffff_ffff) != self
       raise RangeError, "#{self} is outside of the valid character range"
@@ -122,7 +161,7 @@ def chr(enc=undefined)
     String.from_codepoint self, enc
   end
 
-  def round(ndigits=undefined)
+  def round(ndigits=undefined, half: :up)
     return self if undefined.equal? ndigits
 
     if Float === ndigits && ndigits.infinite?
@@ -132,10 +171,13 @@ def round(ndigits=undefined)
     ndigits = Truffle::Type.coerce_to_int(ndigits)
     Truffle::Type.check_int(ndigits)
 
-    if ndigits > 0
-      to_f
-    elsif ndigits == 0
-      self
+    if ndigits >= 0
+      case half
+      when :up, nil, :down, :even
+        self
+      else
+        raise ArgumentError, "invalid rounding mode: #{half}"
+      end
     else
       ndigits = -ndigits
 
@@ -148,7 +190,18 @@ def round(ndigits=undefined)
 
       if kind_of? Integer and f.kind_of? Integer
         x = self < 0 ? -self : self
-        x = (x + f / 2) / f * f
+        case half
+        when :up, nil
+          x = (x + (f / 2)) / f
+        when :down
+          x = x / f
+        when :even
+          x = (x + (f / 2)) / f
+          x = (x / 2) * 2
+        else
+          raise ArgumentError, "invalid rounding mode: #{half}"
+        end
+        x = x * f
         x = -x if self < 0
         return x
       end

spec/tags/core/float/gte_tags.txt

@@ -238,13 +238,7 @@ def math_coerce(other, error=:coerce_error)
     other = Truffle::Interop.unbox_if_needed(other)
     return math_coerce_error(other, error) unless other.respond_to? :coerce
 
-    begin
-      values = other.coerce(self)
-    rescue
-      warn 'Numerical comparison operators will no more rescue exceptions of #coerce', uplevel: 1
-      warn 'in the next release. Return nil in #coerce if the coercion is impossible.', uplevel: 1
-      return math_coerce_error(other, error)
-    end
+    values = other.coerce(self)
 
     unless Truffle::Type.object_kind_of?(values, Array) && values.length == 2
       if error == :no_error
@@ -286,6 +280,7 @@ def redo_coerced(meth, right, *extra)
 
   def redo_compare(meth, right)
     b, a = math_coerce(right, :compare_error)
+    return nil unless b
     a.__send__ meth, b
   end
   private :redo_compare