From 932e916b9e340d3ae52bac2eb57567208dc21d4f Mon Sep 17 00:00:00 2001 From: nobu Date: Sun, 17 May 2015 06:01:47 +0000 Subject: numeric.c: Numeric#positive? and Numeric#negative? * numeric.c (num_positive_p, num_negative_p): add methods Numeric#positive? and Numeric#negative?. [ruby-core:69173] [Feature #11151] * numeric.c (flo_positive_p, flo_negative_p): specialiazed functions for Float. * complex.c (Init_Complex): Complex do not have positive? and negative? methods git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@50522 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 12 ++++++++ NEWS | 5 ++++ complex.c | 3 ++ numeric.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++ test/ruby/test_fixnum.rb | 17 ++++++++++++ test/ruby/test_float.rb | 24 ++++++++++++++++ test/ruby/test_numeric.rb | 24 ++++++++++++++++ test/ruby/test_rational.rb | 10 +++++++ 8 files changed, 163 insertions(+) diff --git a/ChangeLog b/ChangeLog index ce210d4062..90b56804df 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,15 @@ +Sun May 17 15:01:26 2015 Nobuyoshi Nakada + + * numeric.c (num_positive_p, num_negative_p): add methods + Numeric#positive? and Numeric#negative?. + [ruby-core:69173] [Feature #11151] + + * numeric.c (flo_positive_p, flo_negative_p): specialiazed + functions for Float. + + * complex.c (Init_Complex): Complex do not have positive? and + negative? methods + Sun May 17 14:57:42 2015 Eric Wong * lib/webrick/server.rb (accept_client): avoid redundant fcntl call diff --git a/NEWS b/NEWS index b136074ceb..1727572c92 100644 --- a/NEWS +++ b/NEWS @@ -19,6 +19,11 @@ with all sufficient information, see the ChangeLog file. * Enumerable#grep_v is added as inverse version of Enumerable#grep. +* Numeric + + * Numeric#positive? and Numeric#negative? are added, which return + true when the receiver is positive and negative respectively. + === Core classes compatibility issues (excluding feature bug fixes) * Array diff --git a/complex.c b/complex.c index d1cb207c3d..365fb7ad17 100644 --- a/complex.c +++ b/complex.c @@ -2222,6 +2222,9 @@ Init_Complex(void) rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0); rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0); + rb_undef_method(rb_cComplex, "positive?"); + rb_undef_method(rb_cComplex, "negative?"); + 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 848e5fa8f5..e2f330f3bc 100644 --- a/numeric.c +++ b/numeric.c @@ -648,6 +648,42 @@ num_to_int(VALUE num) return rb_funcallv(num, id_to_i, 0, 0); } +/* + * call-seq: + * num.positive? -> true or false + * + * Returns +true+ if +num+ is greater than 0. + */ + +static VALUE +num_positive_p(VALUE num) +{ + const ID mid = '>'; + + if (FIXNUM_P(num)) { + if (method_basic_p(rb_cFixnum)) + return (SIGNED_VALUE)num > (SIGNED_VALUE)INT2FIX(0); + } + else if (RB_TYPE_P(num, T_BIGNUM)) { + if (method_basic_p(rb_cBignum)) + return BIGNUM_POSITIVE_P(num); + } + return RTEST(compare_with_zero(num, mid)); +} + +/* + * call-seq: + * num.positive? -> true or false + * + * Returns +true+ if +num+ is less than 0. + */ + +static VALUE +num_negative_p(VALUE num) +{ + return negative_int_p(num) ? Qtrue : Qfalse; +} + /******************************************************************** * @@ -1828,6 +1864,34 @@ flo_truncate(VALUE num) return LONG2FIX(val); } +/* + * call-seq: + * float.positive? -> true or false + * + * Returns +true+ if +float+ is greater than 0. + */ + +static VALUE +flo_positive_p(VALUE num) +{ + double f = RFLOAT_VALUE(num); + return f > 0.0 ? Qtrue : Qfalse; +} + +/* + * call-seq: + * float.negative? -> true or false + * + * Returns +true+ if +float+ is less than 0. + */ + +static VALUE +flo_negative_p(VALUE num) +{ + double f = RFLOAT_VALUE(num); + return f < 0.0 ? Qtrue : Qfalse; +} + /* * call-seq: * num.floor -> integer @@ -4062,6 +4126,8 @@ Init_Numeric(void) rb_define_method(rb_cNumeric, "round", num_round, -1); rb_define_method(rb_cNumeric, "truncate", num_truncate, 0); rb_define_method(rb_cNumeric, "step", num_step, -1); + rb_define_method(rb_cNumeric, "positive?", num_positive_p, 0); + rb_define_method(rb_cNumeric, "negative?", num_negative_p, 0); rb_cInteger = rb_define_class("Integer", rb_cNumeric); rb_undef_alloc_func(rb_cInteger); @@ -4265,6 +4331,8 @@ Init_Numeric(void) rb_define_method(rb_cFloat, "finite?", flo_is_finite_p, 0); rb_define_method(rb_cFloat, "next_float", flo_next_float, 0); rb_define_method(rb_cFloat, "prev_float", flo_prev_float, 0); + rb_define_method(rb_cFloat, "positive?", flo_positive_p, 0); + rb_define_method(rb_cFloat, "negative?", flo_negative_p, 0); id_to = rb_intern("to"); id_by = rb_intern("by"); diff --git a/test/ruby/test_fixnum.rb b/test/ruby/test_fixnum.rb index 8b2cf2e256..e10371d3e3 100644 --- a/test/ruby/test_fixnum.rb +++ b/test/ruby/test_fixnum.rb @@ -312,4 +312,21 @@ class TestFixnum < Test::Unit::TestCase assert_equal(1, 5.remainder(4)) assert_predicate(4.remainder(Float::NAN), :nan?) end + + def test_zero_p + assert_predicate(0, :zero?) + assert_not_predicate(1, :zero?) + end + + def test_positive_p + assert_predicate(1, :positive?) + assert_not_predicate(0, :positive?) + assert_not_predicate(-1, :positive?) + end + + def test_negative_p + assert_predicate(-1, :negative?) + assert_not_predicate(0, :negative?) + assert_not_predicate(1, :negative?) + end end diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb index eab4d12a29..f1e01fc249 100644 --- a/test/ruby/test_float.rb +++ b/test/ruby/test_float.rb @@ -356,6 +356,30 @@ class TestFloat < Test::Unit::TestCase assert_not_predicate(1.0, :zero?) end + def test_positive_p + assert_predicate(+1.0, :positive?) + assert_not_predicate(+0.0, :positive?) + assert_not_predicate(-0.0, :positive?) + assert_not_predicate(-1.0, :positive?) + assert_predicate(+(0.0.next_float), :positive?) + assert_not_predicate(-(0.0.next_float), :positive?) + assert_predicate(Float::INFINITY, :positive?) + assert_not_predicate(-Float::INFINITY, :positive?) + assert_not_predicate(Float::NAN, :positive?) + end + + def test_negative_p + assert_predicate(-1.0, :negative?) + assert_not_predicate(-0.0, :negative?) + assert_not_predicate(+0.0, :negative?) + assert_not_predicate(+1.0, :negative?) + assert_predicate(-(0.0.next_float), :negative?) + assert_not_predicate(+(0.0.next_float), :negative?) + assert_predicate(-Float::INFINITY, :negative?) + assert_not_predicate(Float::INFINITY, :negative?) + assert_not_predicate(Float::NAN, :negative?) + end + def test_infinite_p inf = Float::INFINITY assert_equal(1, inf.infinite?) diff --git a/test/ruby/test_numeric.rb b/test/ruby/test_numeric.rb index 5a7a4e3765..f539ccf731 100644 --- a/test/ruby/test_numeric.rb +++ b/test/ruby/test_numeric.rb @@ -146,6 +146,30 @@ class TestNumeric < Test::Unit::TestCase assert_predicate(a, :zero?) end + def test_positive_p + a = Class.new(Numeric) do + def >(x); true; end + end.new + assert_predicate(a, :positive?) + + a = Class.new(Numeric) do + def >(x); false; end + end.new + assert_not_predicate(a, :positive?) + end + + def test_negative_p + a = Class.new(Numeric) do + def <(x); true; end + end.new + assert_predicate(a, :negative?) + + a = Class.new(Numeric) do + def <(x); false; end + end.new + assert_not_predicate(a, :negative?) + end + def test_to_int a = Class.new(Numeric) do def to_i; :ok; end diff --git a/test/ruby/test_rational.rb b/test/ruby/test_rational.rb index ae4a2c6dd6..1f32a49273 100644 --- a/test/ruby/test_rational.rb +++ b/test/ruby/test_rational.rb @@ -921,6 +921,16 @@ class Rational_Test < Test::Unit::TestCase assert_raise(ZeroDivisionError, bug5713) { Rational(0, 1) ** Rational(-2,3) } end + def test_positive_p + assert_predicate(1/2r, :positive?) + assert_not_predicate(-1/2r, :positive?) + end + + def test_negative_p + assert_predicate(-1/2r, :negative?) + assert_not_predicate(1/2r, :negative?) + end + def test_known_bug end -- cgit v1.2.3