number 0.9.6 → 0.9.7

data/ext/interval.c

@@ -319,10 +319,6 @@ Interval* interval_divide (Interval* a, Interval* b)
     Interval* interval;
     
     bounds = (RealBounds*)real_bounds_new();
-    real_bounds_update(bounds, (Real*)real_divide(a->l, b->l, ROUND_NEAREST), a->L && b->L);
-    real_bounds_update(bounds, (Real*)real_divide(a->l, b->u, ROUND_NEAREST), a->L && b->R);
-    real_bounds_update(bounds, (Real*)real_divide(a->u, b->l, ROUND_NEAREST), a->R && b->L);
-    real_bounds_update(bounds, (Real*)real_divide(a->u, b->u, ROUND_NEAREST), a->R && b->R);
     real_bounds_update(bounds, (Real*)real_divide(a->l, b->l, ROUND_DOWN), a->L && b->L);
     real_bounds_update(bounds, (Real*)real_divide(a->l, b->u, ROUND_DOWN), a->L && b->R);
     real_bounds_update(bounds, (Real*)real_divide(a->u, b->l, ROUND_DOWN), a->R && b->L);

data/ext/number.c

@@ -3,6 +3,14 @@
 long digs;
 VALUE rb_cNumber;
 
+VALUE rb_NilClass_to_number (VALUE nil)
+{
+    VALUE result = rb_obj_alloc(rb_cNumber);
+    DATA_PTR(result) = (Complex*)complex_nan();
+    
+    return result;
+}
+
 VALUE rb_String_to_number (VALUE str)
 {
     VALUE complex_regex = rb_enc_reg_new("^(.*[^\\s]+)\\s*\\+\\s*(.*)i$", strlen("^(.*[^\\s]+)\\s*\\+\\s*(.*)i$"), rb_utf8_encoding(), 0);
@@ -113,11 +121,14 @@ VALUE rb_Complex_to_number (VALUE complex)
 
 VALUE rb_f_Number (int argc, VALUE* argv, VALUE obj)
 {
-    int L;
-    int R;
     Complex* tmp1;
     Complex* tmp2;
     Complex* tmp3;
+    Interval* i1;
+    Interval* i2;
+    VALUE tmp_A;
+    VALUE tmp_B;
+    VALUE tmp_C;
     VALUE arg1;
     VALUE arg2;
     VALUE arg3;
@@ -128,25 +139,52 @@ VALUE rb_f_Number (int argc, VALUE* argv, VALUE obj)
     switch (rb_scan_args(argc, argv, "14", &arg1, &arg2, &arg3, &arg4, &arg5))
     {
         case 1:
-            DATA_PTR(result) = (Complex*)complex_dup(DATA_PTR(rb_convert_type(arg1, T_DATA, "Number", "to_number")));
+            tmp_A = rb_convert_type(arg1, T_DATA, "Number", "to_number");
+            tmp1 = (Complex*)DATA_PTR(tmp_A);
+            
+            DATA_PTR(result) = (Complex*)complex_dup(tmp1);
             break;
         
         case 2:
-            tmp1 = (Complex*)DATA_PTR(rb_convert_type(arg1, T_DATA, "Number", "to_number"));
-            tmp2 = (Complex*)DATA_PTR(rb_convert_type(arg2, T_DATA, "Number", "to_number"));
+            tmp_A = rb_convert_type(arg1, T_DATA, "Number", "to_number");
+            tmp_B = rb_convert_type(arg2, T_DATA, "Number", "to_number");
             
-            DATA_PTR(result) = (Complex*)complex_new((Interval*)interval_dup(tmp1->re), (Interval*)interval_dup(tmp2->re));
+            tmp1 = (Complex*)DATA_PTR(tmp_A);
+            tmp2 = (Complex*)DATA_PTR(tmp_B);
+            
+            Interval* re1 = (Interval*)tmp1->re;
+            Interval* re2 = (Interval*)tmp2->re;
+            
+            i1 = (Interval*)interval_dup(re1);
+            i2 = (Interval*)interval_dup(re2);
+            
+            DATA_PTR(result) = (Complex*)complex_new(i1, i2);
             break;
         
         default:
-            L = (argc == 3) ? true : RTEST(arg4);
-            R = (argc == 5) ? RTEST(arg5) : L;
+            tmp_A = rb_convert_type(arg1, T_DATA, "Number", "to_number");
+            tmp_B = rb_convert_type(arg2, T_DATA, "Number", "to_number");
+            tmp_C = rb_convert_type(arg3, T_DATA, "Number", "to_number");
+            
+            tmp1 = (Complex*)DATA_PTR(tmp_A);
+            tmp2 = (Complex*)DATA_PTR(tmp_B);
+            tmp3 = (Complex*)DATA_PTR(tmp_C);
+            
+            Real* n1 = (Real*)tmp1->re->n;
+            Real* n2 = (Real*)tmp2->re->n;
+            Real* n3 = (Real*)tmp3->re->n;
+            
+            Real* r1 = (Real*)real_dup(n1);
+            Real* r2 = (Real*)real_dup(n2);
+            Real* r3 = (Real*)real_dup(n3);
+            
+            int L = (argc == 3) ? true : RTEST(arg4);
+            int R = (argc == 5) ? RTEST(arg5) : L;
             
-            tmp1 = (Complex*)DATA_PTR(rb_convert_type(arg1, T_DATA, "Number", "to_number"));
-            tmp2 = (Complex*)DATA_PTR(rb_convert_type(arg2, T_DATA, "Number", "to_number"));
-            tmp3 = (Complex*)DATA_PTR(rb_convert_type(arg3, T_DATA, "Number", "to_number"));
+            i1 = (Interval*)interval_new(r1, L, r2, R, r3);
+            i2 = (Interval*)interval_zero();
             
-            DATA_PTR(result) = (Complex*)complex_new((Interval*)interval_new((Real*)real_dup(tmp1->re->n), L, (Real*)real_dup(tmp2->re->n), R, (Real*)real_dup(tmp3->re->n)), (Interval*)interval_zero());
+            DATA_PTR(result) = (Complex*)complex_new(i1, i2);
             break;
     }
     
@@ -1387,6 +1425,7 @@ void Init_number ()
     init_real_tmp_nums();
     init_complex_tmp_nums();
     
+    rb_define_method(rb_cNilClass, "to_number", rb_NilClass_to_number, 0);
     rb_define_method(rb_cString, "to_number", rb_String_to_number, 0);
     rb_define_method(rb_cInteger, "to_number", rb_Integer_to_number, 0);
     rb_define_method(rb_cFloat, "to_number", rb_Float_to_number, 0);

data/ext/real.c

@@ -530,7 +530,7 @@ Real* real_e (int round_mode)
  */
 Real* real_dup (Real* real)
 {
-    return REAL(real) ? real_new_exact(real->num, real->exp) : real_new_flagged(real->flag);
+    return REAL(real) ? (Real*)real_new_exact(real->num, real->exp) : (Real*)real_new_flagged(real->flag);
 }
 
 /*

metadata

@@ -2,7 +2,7 @@
 name: number
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-18 00:00:00 Z
+date: 2011-07-27 00:00:00 Z
 dependencies: []
 
 description: The Number gem is intended to be a drop-in replacement for Ruby's Numeric classes when arbitrary-precision complex interval calculations are warranted. The basis of the arbitrary-precision calculations is the GNU MP, MPFR, and MPC libraries.