ruby-changes:46470
From: stomar <ko1@a...>
Date: Sun, 7 May 2017 04:58:21 +0900 (JST)
Subject: [ruby-changes:46470] stomar:r58586 (trunk): make Integer#{round, floor, ceil, truncate} always return integer
stomar 2017-05-07 04:58:12 +0900 (Sun, 07 May 2017) New Revision: 58586 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=58586 Log: make Integer#{round,floor,ceil,truncate} always return integer * numeric.c (int_round): return integer (self) instead of float for Integer#round with positive ndigits argument, because conversion to float introduces errors for large integers. * numeric.c (int_floor): ditto for Integer#floor. * numeric.c (int_ceil): ditto for Integer#ceil. * numeric.c (int_truncate): ditto for Integer#truncate. * test/ruby/test_integer.rb: adjust test cases and add some more. [ruby-core:80645] [Bug #13420] Modified files: trunk/numeric.c trunk/test/ruby/test_integer.rb Index: test/ruby/test_integer.rb =================================================================== --- test/ruby/test_integer.rb (revision 58585) +++ test/ruby/test_integer.rb (revision 58586) @@ -181,8 +181,8 @@ class TestInteger < Test::Unit::TestCase https://github.com/ruby/ruby/blob/trunk/test/ruby/test_integer.rb#L181 assert_int_equal(11111, 11111.round) assert_int_equal(11111, 11111.round(0)) - assert_float_equal(11111.0, 11111.round(1)) - assert_float_equal(11111.0, 11111.round(2)) + assert_int_equal(11111, 11111.round(1)) + assert_int_equal(11111, 11111.round(2)) assert_int_equal(11110, 11111.round(-1)) assert_int_equal(11100, 11111.round(-2)) @@ -249,14 +249,17 @@ class TestInteger < Test::Unit::TestCase https://github.com/ruby/ruby/blob/trunk/test/ruby/test_integer.rb#L249 assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1110, 1111_1111_1111_1111_1111_1111_1111_1111.round(-1)) assert_int_equal(-1111_1111_1111_1111_1111_1111_1111_1110, (-1111_1111_1111_1111_1111_1111_1111_1111).round(-1)) + + assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1111, 1111_1111_1111_1111_1111_1111_1111_1111.round(1)) + assert_int_equal(10**400, (10**400).round(1)) end def test_floor assert_int_equal(11111, 11111.floor) assert_int_equal(11111, 11111.floor(0)) - assert_float_equal(11111.0, 11111.floor(1)) - assert_float_equal(11111.0, 11111.floor(2)) + assert_int_equal(11111, 11111.floor(1)) + assert_int_equal(11111, 11111.floor(2)) assert_int_equal(11110, 11110.floor(-1)) assert_int_equal(11110, 11119.floor(-1)) @@ -274,14 +277,17 @@ class TestInteger < Test::Unit::TestCase https://github.com/ruby/ruby/blob/trunk/test/ruby/test_integer.rb#L277 assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1110, 1111_1111_1111_1111_1111_1111_1111_1111.floor(-1)) assert_int_equal(-1111_1111_1111_1111_1111_1111_1111_1120, (-1111_1111_1111_1111_1111_1111_1111_1111).floor(-1)) + + assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1111, 1111_1111_1111_1111_1111_1111_1111_1111.floor(1)) + assert_int_equal(10**400, (10**400).floor(1)) end def test_ceil assert_int_equal(11111, 11111.ceil) assert_int_equal(11111, 11111.ceil(0)) - assert_float_equal(11111.0, 11111.ceil(1)) - assert_float_equal(11111.0, 11111.ceil(2)) + assert_int_equal(11111, 11111.ceil(1)) + assert_int_equal(11111, 11111.ceil(2)) assert_int_equal(11110, 11110.ceil(-1)) assert_int_equal(11120, 11119.ceil(-1)) @@ -299,14 +305,17 @@ class TestInteger < Test::Unit::TestCase https://github.com/ruby/ruby/blob/trunk/test/ruby/test_integer.rb#L305 assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1120, 1111_1111_1111_1111_1111_1111_1111_1111.ceil(-1)) assert_int_equal(-1111_1111_1111_1111_1111_1111_1111_1110, (-1111_1111_1111_1111_1111_1111_1111_1111).ceil(-1)) + + assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1111, 1111_1111_1111_1111_1111_1111_1111_1111.ceil(1)) + assert_int_equal(10**400, (10**400).ceil(1)) end def test_truncate assert_int_equal(11111, 11111.truncate) assert_int_equal(11111, 11111.truncate(0)) - assert_float_equal(11111.0, 11111.truncate(1)) - assert_float_equal(11111.0, 11111.truncate(2)) + assert_int_equal(11111, 11111.truncate(1)) + assert_int_equal(11111, 11111.truncate(2)) assert_int_equal(11110, 11110.truncate(-1)) assert_int_equal(11110, 11119.truncate(-1)) @@ -324,6 +333,9 @@ class TestInteger < Test::Unit::TestCase https://github.com/ruby/ruby/blob/trunk/test/ruby/test_integer.rb#L333 assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1110, 1111_1111_1111_1111_1111_1111_1111_1111.truncate(-1)) assert_int_equal(-1111_1111_1111_1111_1111_1111_1111_1110, (-1111_1111_1111_1111_1111_1111_1111_1111).truncate(-1)) + + assert_int_equal(1111_1111_1111_1111_1111_1111_1111_1111, 1111_1111_1111_1111_1111_1111_1111_1111.truncate(1)) + assert_int_equal(10**400, (10**400).truncate(1)) end MimicInteger = Struct.new(:to_int) Index: numeric.c =================================================================== --- numeric.c (revision 58585) +++ numeric.c (revision 58586) @@ -4985,11 +4985,10 @@ int_dotimes(VALUE num) https://github.com/ruby/ruby/blob/trunk/numeric.c#L4985 * When the precision is negative, the returned value is an integer * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns a floating point number when +ndigits+ is positive, - * +self+ for zero, and an integer for negative. + * Returns +self+ when +ndigits+ is zero or positive. * * 1.round #=> 1 - * 1.round(2) #=> 1.0 + * 1.round(2) #=> 1 * 15.round(-1) #=> 20 * (-15).round(-1) #=> -20 * @@ -5017,10 +5016,7 @@ int_round(int argc, VALUE* argv, VALUE n https://github.com/ruby/ruby/blob/trunk/numeric.c#L5016 if (!rb_scan_args(argc, argv, "01:", &nd, &opt)) return num; ndigits = NUM2INT(nd); mode = rb_num_get_rounding_option(opt); - if (ndigits > 0) { - return rb_Float(num); - } - if (ndigits == 0) { + if (ndigits >= 0) { return num; } return rb_int_round(num, ndigits, mode); @@ -5037,11 +5033,10 @@ int_round(int argc, VALUE* argv, VALUE n https://github.com/ruby/ruby/blob/trunk/numeric.c#L5033 * When the precision is negative, the returned value is an integer * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns a floating point number when +ndigits+ is positive, - * +self+ for zero, and an integer for negative. + * Returns +self+ when +ndigits+ is zero or positive. * * 1.floor #=> 1 - * 1.floor(2) #=> 1.0 + * 1.floor(2) #=> 1 * 18.floor(-1) #=> 10 * (-18).floor(-1) #=> -20 */ @@ -5053,10 +5048,7 @@ int_floor(int argc, VALUE* argv, VALUE n https://github.com/ruby/ruby/blob/trunk/numeric.c#L5048 if (!rb_check_arity(argc, 0, 1)) return num; ndigits = NUM2INT(argv[0]); - if (ndigits > 0) { - return rb_Float(num); - } - if (ndigits == 0) { + if (ndigits >= 0) { return num; } return rb_int_floor(num, ndigits); @@ -5073,11 +5065,10 @@ int_floor(int argc, VALUE* argv, VALUE n https://github.com/ruby/ruby/blob/trunk/numeric.c#L5065 * When the precision is negative, the returned value is an integer * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns a floating point number when +ndigits+ is positive, - * +self+ for zero, and an integer for negative. + * Returns +self+ when +ndigits+ is zero or positive. * * 1.ceil #=> 1 - * 1.ceil(2) #=> 1.0 + * 1.ceil(2) #=> 1 * 18.ceil(-1) #=> 20 * (-18).ceil(-1) #=> -10 */ @@ -5089,10 +5080,7 @@ int_ceil(int argc, VALUE* argv, VALUE nu https://github.com/ruby/ruby/blob/trunk/numeric.c#L5080 if (!rb_check_arity(argc, 0, 1)) return num; ndigits = NUM2INT(argv[0]); - if (ndigits > 0) { - return rb_Float(num); - } - if (ndigits == 0) { + if (ndigits >= 0) { return num; } return rb_int_ceil(num, ndigits); @@ -5109,11 +5097,10 @@ int_ceil(int argc, VALUE* argv, VALUE nu https://github.com/ruby/ruby/blob/trunk/numeric.c#L5097 * When the precision is negative, the returned value is an integer * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns a floating point number when +ndigits+ is positive, - * +self+ for zero, and an integer for negative. + * Returns +self+ when +ndigits+ is zero or positive. * * 1.truncate #=> 1 - * 1.truncate(2) #=> 1.0 + * 1.truncate(2) #=> 1 * 18.truncate(-1) #=> 10 * (-18).truncate(-1) #=> -10 */ @@ -5125,10 +5112,7 @@ int_truncate(int argc, VALUE* argv, VALU https://github.com/ruby/ruby/blob/trunk/numeric.c#L5112 if (!rb_check_arity(argc, 0, 1)) return num; ndigits = NUM2INT(argv[0]); - if (ndigits > 0) { - return rb_Float(num); - } - if (ndigits == 0) { + if (ndigits >= 0) { return num; } return rb_int_truncate(num, ndigits); -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/