number 0.9.3 → 0.9.4

data/ext/number.c

@@ -3,6 +3,84 @@
 long digs;
 VALUE rb_cNumber;
 
+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);
+    VALUE complex_match = rb_funcall(complex_regex, rb_intern("match"), 1, str);
+    
+    if (RTEST(complex_match))
+    {
+        VALUE complex_captures = rb_funcall(complex_match, rb_intern("captures"), 0);
+        return rb_funcall(Qnil, rb_intern("Number"), 2, RARRAY_PTR(complex_captures)[0], RARRAY_PTR(complex_captures)[1]);
+    }
+    else
+    {
+        VALUE interval_regex = rb_enc_reg_new("^\\[(.*[^\\s]+)\\s*([<≤])\\s*\\((.*[^\\s]+)\\)\\s*([<≤])\\s*(.*[^\\s]+)\\]$", strlen("^\\[(.*[^\\s]+)\\s*([<≤])\\s*\\((.*[^\\s]+)\\)\\s*([<≤])\\s*(.*[^\\s]+)\\]$"), rb_utf8_encoding(), 0);
+        VALUE interval_match = rb_funcall(interval_regex, rb_intern("match"), 1, str);
+        
+        if (RTEST(interval_match))
+        {
+            VALUE interval_captures = rb_funcall(interval_match, rb_intern("captures"), 0);
+            return rb_funcall(Qnil, rb_intern("Number"), 5, RARRAY_PTR(interval_captures)[0], RARRAY_PTR(interval_captures)[2], RARRAY_PTR(interval_captures)[4], *RSTRING_PTR(RARRAY_PTR(interval_captures)[2]) == '<' ? Qtrue : Qfalse, *RSTRING_PTR(RARRAY_PTR(interval_captures)[4]) == '<' ? Qtrue : Qfalse);
+        }
+        else
+        {
+            VALUE real_regex = rb_enc_reg_new("^([+-]?[0-9]+):([+-]?[0-9]+)$", strlen("^([+-]?[0-9]+):([+-]?[0-9]+)$"), rb_utf8_encoding(), 0);
+            VALUE real_match = rb_funcall(real_regex, rb_intern("match"), 1, str);
+            
+            if (RTEST(real_match))
+            {
+                VALUE real_captures = rb_funcall(real_match, rb_intern("captures"), 0);
+                VALUE result = rb_obj_alloc(rb_cNumber);
+                Real* real = (Real*)real_from_str(RSTRING_PTR(RARRAY_PTR(real_captures)[0]), NUM2LONG(rb_funcall(RARRAY_PTR(real_captures)[1], rb_intern("to_i"), 0)));
+                
+                DATA_PTR(result) = (Complex*)complex_from_real(real);
+                real_free(real);
+                
+                return result;
+            }
+            else if ((long)RSTRING_PTR(str)[0] == -61)
+            {
+                VALUE result = rb_obj_alloc(rb_cNumber);
+                DATA_PTR(result) = (Complex*)complex_nan();
+                
+                return result;
+            }
+            else if ((long)RSTRING_PTR(str)[0] == -30)
+            {
+                VALUE result = rb_obj_alloc(rb_cNumber);
+                DATA_PTR(result) = (Complex*)complex_pos_inf();
+                
+                return result;
+            }
+            else if (((long)RSTRING_PTR(str)[0] == 43 || (long)RSTRING_PTR(str)[0] == 45) && (long)RSTRING_PTR(str)[1] == -30)
+            {
+                VALUE result = rb_obj_alloc(rb_cNumber);
+                DATA_PTR(result) = ((long)RSTRING_PTR(str)[0] == 43) ? (Complex*)complex_pos_inf() : (Complex*)complex_neg_inf();
+                
+                return result;
+            }
+            else
+            {
+                VALUE integer_regex = rb_enc_reg_new("^([+-]?[0-9]+)$", strlen("^([+-]?[0-9]+)$"), rb_utf8_encoding(), 0);
+                VALUE integer_match = rb_funcall(integer_regex, rb_intern("match"), 1, str);
+                
+                if (RTEST(integer_match))
+                {
+                    return rb_funcall(rb_funcall(str, rb_intern("to_i"), 0), rb_intern("to_number"), 0);
+                }
+                else
+                {
+                    return rb_funcall(rb_funcall(str, rb_intern("to_f"), 0), rb_intern("to_number"), 0);
+                }
+            }
+        }
+    }
+    
+    /* not reached */
+    return Qnil;
+}
+
 VALUE rb_Integer_to_number (VALUE integer)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
@@ -1277,6 +1355,7 @@ void Init_number ()
     
     digs = 17;
     
+    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);
     rb_define_method(rb_cComplex, "to_number", rb_Complex_to_number, 0);

data/ext/real.c

@@ -797,6 +797,11 @@ Real* real_divide (Real* a, Real* b, int round_mode)
     mpfr_t b_num;
     mpfr_t num;
     
+    if (!REAL(a) || !REAL(b))
+    {
+        return (NaN(a) || NaN(b) || (!REAL(a) && !REAL(b))) ? real_nan() : !REAL(b) ? real_zero() : (POS(a) && POS(b)) ? real_pos_inf() : real_neg_inf();
+    }
+    
     mpfr_init2(num, PREC);
     mpfr_init_set_r(a_num, a);
     mpfr_init_set_r(b_num, b);

metadata

@@ -2,7 +2,7 @@
 name: number
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-15 00:00:00 Z
+date: 2011-07-16 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.