tadf	2009-07-03 19:50:17 +0900 (Fri, 03 Jul 2009)

  New Revision: 23946

  http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=23946

  Log:
    * complex.c: undef-ed shome methods.  [ruby-core:24110]
    * complex.c (Numeric#arg): NaN for NaN.  [ruby-core:24116]

  Modified files:
    trunk/ChangeLog
    trunk/complex.c
    trunk/test/ruby/test_complex.rb

Index: complex.c
===================================================================
--- complex.c	(revision 23945)
+++ complex.c	(revision 23946)
@@ -1690,9 +1690,9 @@
 
 /*
  * call-seq:
- *    num.arg    ->  float
- *    num.angle  ->  float
- *    num.phase  ->  float
+ *    num.arg    ->  0 or float
+ *    num.angle  ->  0 or float
+ *    num.phase  ->  0 or float
  *
  * Returns 0 if the value is positive, pi otherwise.
  */
@@ -1742,6 +1742,22 @@
 }
 
 /*
+ * call-seq:
+ *    flo.arg    ->  0 or float
+ *    flo.angle  ->  0 or float
+ *    flo.phase  ->  0 or float
+ *
+ * Returns 0 if the value is positive, pi otherwise.
+ */
+static VALUE
+float_arg(VALUE self)
+{
+    if (isnan(RFLOAT_VALUE(self)))
+	return self;
+    return rb_call_super(0, 0);
+}
+
+/*
  * A complex number can be represented as a paired real number with
  * imaginary unit; a+bi.  Where a is real part, b is imaginary part
  * and i is imaginary unit.  Real a equals complex a+0i
@@ -1824,16 +1840,19 @@
 
     rb_define_global_function("Complex", nucomp_f_complex, -1);
 
+    rb_undef_method(rb_cComplex, "%");
     rb_undef_method(rb_cComplex, "<");
     rb_undef_method(rb_cComplex, "<=");
     rb_undef_method(rb_cComplex, "<=>");
     rb_undef_method(rb_cComplex, ">");
     rb_undef_method(rb_cComplex, ">=");
     rb_undef_method(rb_cComplex, "between?");
+    rb_undef_method(rb_cComplex, "div");
     rb_undef_method(rb_cComplex, "divmod");
     rb_undef_method(rb_cComplex, "floor");
     rb_undef_method(rb_cComplex, "ceil");
     rb_undef_method(rb_cComplex, "modulo");
+    rb_undef_method(rb_cComplex, "remainder");
     rb_undef_method(rb_cComplex, "round");
     rb_undef_method(rb_cComplex, "step");
     rb_undef_method(rb_cComplex, "truncate");
@@ -1921,6 +1940,10 @@
     rb_define_method(rb_cNumeric, "conjugate", numeric_conj, 0);
     rb_define_method(rb_cNumeric, "conj", numeric_conj, 0);
 
+    rb_define_method(rb_cFloat, "arg", float_arg, 0);
+    rb_define_method(rb_cFloat, "angle", float_arg, 0);
+    rb_define_method(rb_cFloat, "phase", float_arg, 0);
+
     rb_define_const(rb_cComplex, "I",
 		    f_complex_new_bang2(rb_cComplex, ZERO, ONE));
 }
Index: ChangeLog
===================================================================
--- ChangeLog	(revision 23945)
+++ ChangeLog	(revision 23946)
@@ -1,3 +1,9 @@
+Fri Jul  3 19:48:40 2009  Tadayoshi Funaba  <tadf@d...>
+
+	* complex.c: undef-ed shome methods.  [ruby-core:24110]
+
+	* complex.c (Numeric#arg): NaN for NaN.  [ruby-core:24116]
+
 Fri Jul  3 18:35:06 2009  Nobuyoshi Nakada  <nobu@r...>
 
 	* vm_core.h (struct rb_iseq_struct): fixed types.
Index: test/ruby/test_complex.rb
===================================================================
--- test/ruby/test_complex.rb	(revision 23945)
+++ test/ruby/test_complex.rb	(revision 23946)
@@ -519,7 +519,7 @@
       assert_instance_of(Fixnum, Complex(1,2) - Complex(1,2))
       assert_instance_of(Fixnum, Complex(1,2) * 0)
       assert_instance_of(Fixnum, Complex(1,2) / Complex(1,2))
-      assert_instance_of(Fixnum, Complex(1,2).div(Complex(1,2)))
+#      assert_instance_of(Fixnum, Complex(1,2).div(Complex(1,2)))
       assert_instance_of(Fixnum, Complex(1,2).quo(Complex(1,2)))
 #      assert_instance_of(Fixnum, Complex(1,2) ** 0) # mathn's bug
     end
@@ -779,17 +779,19 @@
 
   def test_respond
     c = Complex(1,1)
+    assert_equal(false, c.respond_to?(:%))
     assert_equal(false, c.respond_to?(:<))
     assert_equal(false, c.respond_to?(:<=))
     assert_equal(false, c.respond_to?(:<=>))
     assert_equal(false, c.respond_to?(:>))
     assert_equal(false, c.respond_to?(:>=))
     assert_equal(false, c.respond_to?(:between?))
-#    assert_equal(false, c.respond_to?(:div)) # ?
+    assert_equal(false, c.respond_to?(:div))
     assert_equal(false, c.respond_to?(:divmod))
     assert_equal(false, c.respond_to?(:floor))
     assert_equal(false, c.respond_to?(:ceil))
     assert_equal(false, c.respond_to?(:modulo))
+    assert_equal(false, c.respond_to?(:remainder))
     assert_equal(false, c.respond_to?(:round))
     assert_equal(false, c.respond_to?(:step))
     assert_equal(false, c.respond_to?(:tunrcate))

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/