diff --git a/ChangeLog b/ChangeLog index e3ba23cdbf..583e7e822a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,23 @@ +Sun Jul 17 23:42:00 2016 Kenta Murata + + * numeric.c (num_finite_p, num_infinite_p): Add Numeric#finite? and + Numeric#infinite? [Feature #12039] [ruby-core:73618] + + * complex.c (rb_complex_finite_p): Add Complex#finite? + + * complex.c (rb_complex_infinite_p): Add Complex#infinite? + + * test/ruby/test_bignum.rb: Add test for Integer#finite? and + Integer#infinite? + + * test/ruby/test_fixnum.rb: ditto. + + * test/ruby/test_rational.rb: Add test for Rational#finite? and + Rational#infinite? + + * test/ruby/test_complex.rb: Add test for Complex#finite? and + Complex#infinite? + Sun Jul 17 20:59:24 2016 Nobuyoshi Nakada * common.mk, enc/depend (casefold.h, name2ctype.h): move to diff --git a/complex.c b/complex.c index fc6ecbb0e0..def0758276 100644 --- a/complex.c +++ b/complex.c @@ -1331,6 +1331,68 @@ nucomp_inspect(VALUE self) return s; } +/* + * call-seq: + * cmp.finite? -> true or false + * + * Returns +true+ if +cmp+'s magnitude is finite number, + * oterwise returns +false+. + */ +static VALUE +rb_complex_finite_p(VALUE self) +{ + VALUE magnitude = nucomp_abs(self); + double f; + + switch (TYPE(magnitude)) { + case T_FIXNUM: case T_BIGNUM: case T_RATIONAL: + return Qtrue; + + case T_FLOAT: + f = RFLOAT_VALUE(magnitude); + return isinf(f) ? Qfalse : Qtrue; + + default: + return rb_funcall(magnitude, rb_intern("finite?"), 0); + } +} + +/* + * call-seq: + * cmp.infinite? -> nil or 1 or -1 + * + * Returns values corresponding to the value of +cmp+'s magnitude: + * + * +finite+:: +nil+ + * ++Infinity+:: ++1+ + * + * For example: + * + * (1+1i).infinite? #=> nil + * (Float::INFINITY + 1i).infinite? #=> 1 + */ +static VALUE +rb_complex_infinite_p(VALUE self) +{ + VALUE magnitude = nucomp_abs(self); + double f; + + switch (TYPE(magnitude)) { + case T_FIXNUM: case T_BIGNUM: case T_RATIONAL: + return Qnil; + + case T_FLOAT: + f = RFLOAT_VALUE(magnitude); + if (isinf(f)) { + return INT2FIX(f < 0 ? -1 : 1); + } + return Qnil; + + default: + return rb_funcall(magnitude, rb_intern("infinite?"), 0); + } +} + /* :nodoc: */ static VALUE nucomp_dumper(VALUE self) @@ -2233,6 +2295,9 @@ Init_Complex(void) rb_undef_method(rb_cComplex, "positive?"); rb_undef_method(rb_cComplex, "negative?"); + rb_define_method(rb_cComplex, "finite?", rb_complex_finite_p, 0); + rb_define_method(rb_cComplex, "infinite?", rb_complex_infinite_p, 0); + rb_define_private_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0); compat = rb_define_class_under(rb_cComplex, "compatible", rb_cObject); /* :nodoc: */ rb_define_private_method(compat, "marshal_load", nucomp_marshal_load, 1); diff --git a/numeric.c b/numeric.c index 7296ab704a..0c0ca82b49 100644 --- a/numeric.c +++ b/numeric.c @@ -671,6 +671,34 @@ num_nonzero_p(VALUE num) return num; } +/* + * call-seq: + * num.finite? -> true or false + * + * Return true if +num+ is finite number, oterwise returns false. + */ +static VALUE +num_finite_p(VALUE num) +{ + return Qtrue; +} + +/* + * call-seq: + * num.infinite? -> nil or 1 or -1 + * + * Returns values corresponding to the value of +num+'s magnitude: + * + * +finite+:: +nil+ + * +-Infinity+:: +-1+ + * ++Infinity+:: ++1+ + */ +static VALUE +num_infinite_p(VALUE num) +{ + return Qnil; +} + /* * call-seq: * num.to_int -> integer @@ -5002,6 +5030,8 @@ Init_Numeric(void) rb_define_method(rb_cNumeric, "integer?", num_int_p, 0); rb_define_method(rb_cNumeric, "zero?", num_zero_p, 0); rb_define_method(rb_cNumeric, "nonzero?", num_nonzero_p, 0); + rb_define_method(rb_cNumeric, "finite?", num_finite_p, 0); + rb_define_method(rb_cNumeric, "infinite?", num_infinite_p, 0); rb_define_method(rb_cNumeric, "floor", num_floor, -1); rb_define_method(rb_cNumeric, "ceil", num_ceil, -1); diff --git a/test/ruby/test_bignum.rb b/test/ruby/test_bignum.rb index 582a326eb6..15811d5d43 100644 --- a/test/ruby/test_bignum.rb +++ b/test/ruby/test_bignum.rb @@ -778,5 +778,15 @@ class TestBignum < Test::Unit::TestCase assert_raise(TypeError) { T1024P.digits("10") } assert_raise(TypeError) { T1024P.digits("a") } end + + def test_finite_p + assert_predicate(T1024P, :finite?) + assert_predicate(-T1024P, :finite?) + end + + def test_infinite_p + assert_nil(T1024P.infinite?) + assert_nil((-T1024P).infinite?) + end end end diff --git a/test/ruby/test_complex.rb b/test/ruby/test_complex.rb index 6d189f46dd..93d24a194a 100644 --- a/test/ruby/test_complex.rb +++ b/test/ruby/test_complex.rb @@ -826,6 +826,30 @@ class Complex_Test < Test::Unit::TestCase end end + def test_finite_p + assert_predicate(1+1i, :finite?) + assert_predicate(1-1i, :finite?) + assert_predicate(-1+1i, :finite?) + assert_predicate(-1-1i, :finite?) + assert_not_predicate(Float::INFINITY + 1i, :finite?) + assert_not_predicate(Complex(1, Float::INFINITY), :finite?) + end + + def test_infinite_p + assert_nil((1+1i).infinite?) + assert_nil((1-1i).infinite?) + assert_nil((-1+1i).infinite?) + assert_nil((-1-1i).infinite?) + assert_equal(1, (Float::INFINITY + 1i).infinite?) + assert_equal(1, (Float::INFINITY - 1i).infinite?) + assert_equal(1, (-Float::INFINITY + 1i).infinite?) + assert_equal(1, (-Float::INFINITY - 1i).infinite?) + assert_equal(1, Complex(1, Float::INFINITY).infinite?) + assert_equal(1, Complex(-1, Float::INFINITY).infinite?) + assert_equal(1, Complex(1, -Float::INFINITY).infinite?) + assert_equal(1, Complex(-1, -Float::INFINITY).infinite?) + end + def test_supp assert_equal(true, 1.real?) assert_equal(true, 1.1.real?) diff --git a/test/ruby/test_fixnum.rb b/test/ruby/test_fixnum.rb index 3a1c2fa8bc..bd18067dda 100644 --- a/test/ruby/test_fixnum.rb +++ b/test/ruby/test_fixnum.rb @@ -337,4 +337,16 @@ class TestFixnum < Test::Unit::TestCase assert_not_predicate(0, :negative?) assert_not_predicate(1, :negative?) end + + def test_finite_p + assert_predicate(1, :finite?) + assert_predicate(0, :finite?) + assert_predicate(-1, :finite?) + end + + def test_infinite_p + assert_nil(1.infinite?) + assert_nil(0.infinite?) + assert_nil(-1.infinite?) + end end diff --git a/test/ruby/test_rational.rb b/test/ruby/test_rational.rb index 07d0ae5688..1fa9ebe865 100644 --- a/test/ruby/test_rational.rb +++ b/test/ruby/test_rational.rb @@ -939,4 +939,13 @@ class Rational_Test < Test::Unit::TestCase def test_known_bug end + def test_finite_p + assert_predicate(1/2r, :finite?) + assert_predicate(-1/2r, :finite?) + end + + def test_infinite_p + assert_nil((1/2r).infinite?) + assert_nil((-1/2r).infinite?) + end end