number 0.9.7 → 0.9.9

data/ext/{interval.c → number/interval.c}

@@ -78,7 +78,7 @@ int interval_span_zero_p (Interval* interval)
     int result;
     Real* zero;
     
-    zero = (Real*)real_zero();
+    zero = real_zero();
     result = interval_span_p(interval, zero);
     
     real_free(zero);
@@ -94,7 +94,7 @@ int interval_zero_p (Interval* interval)
     int result;
     Real* zero;
     
-    zero = (Real*)real_zero();
+    zero = real_zero();
     result = real_eq_p(interval->l, zero) && real_eq_p(interval->u, zero);
     
     real_free(zero);
@@ -120,7 +120,7 @@ int interval_degenerate_p (Interval* interval)
 Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
 {
     Interval* interval;
-    interval = (Interval*)malloc(sizeof(Interval));
+    interval = malloc(sizeof(Interval));
     
     if (interval == NULL)
     {
@@ -131,9 +131,9 @@ Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
     
     if (NaN(l) || NaN(n) || NaN(u))
     {
-        interval->n = (Real*)real_nan();
-        interval->l = (Real*)real_neg_inf();
-        interval->u = (Real*)real_pos_inf();
+        interval->n = real_nan();
+        interval->l = real_neg_inf();
+        interval->u = real_pos_inf();
         
         interval->L = true;
         interval->R = true;
@@ -144,12 +144,12 @@ Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
     }
     else
     {
-        interval->n = (Real*)n;
-        interval->l = (Real*)l;
-        interval->u = (Real*)u;
+        interval->n = n;
+        interval->l = l;
+        interval->u = u;
         
-        interval->L = real_eq_p(interval->l, interval->u) || real_eq_p(interval->n, interval->l) || L;
-        interval->R = real_eq_p(interval->l, interval->u) || real_eq_p(interval->n, interval->u) || R;
+        interval->L = (real_eq_p(l, u) || real_eq_p(n, l) || L);
+        interval->R = (real_eq_p(l, u) || real_eq_p(n, u) || R);
     }
     
     return interval;
@@ -162,7 +162,7 @@ Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
  */
 Interval* interval_from_real (Real* real)
 {
-    return interval_new((Real*)real_dup(real), true, (Real*)real_dup(real), true, (Real*)real_dup(real));
+    return interval_new(real_dup(real), true, real_dup(real), true, real_dup(real));
 }
 
 /*
@@ -170,7 +170,7 @@ Interval* interval_from_real (Real* real)
  */
 Interval* interval_nan ()
 {
-    return interval_new((Real*)real_neg_inf(), true, (Real*)real_nan(), true, (Real*)real_pos_inf());
+    return interval_new(real_neg_inf(), true, real_nan(), true, real_pos_inf());
 }
 
 /*
@@ -178,7 +178,7 @@ Interval* interval_nan ()
  */
 Interval* interval_pos_inf ()
 {
-    return interval_new((Real*)real_pos_inf(), true, (Real*)real_pos_inf(), true, (Real*)real_pos_inf());
+    return interval_new(real_pos_inf(), true, real_pos_inf(), true, real_pos_inf());
 }
 
 /*
@@ -186,7 +186,7 @@ Interval* interval_pos_inf ()
  */
 Interval* interval_neg_inf ()
 {
-    return interval_new((Real*)real_neg_inf(), true, (Real*)real_neg_inf(), true, (Real*)real_neg_inf());
+    return interval_new(real_neg_inf(), true, real_neg_inf(), true, real_neg_inf());
 }
 
 /*
@@ -194,7 +194,7 @@ Interval* interval_neg_inf ()
  */
 Interval* interval_zero ()
 {
-    return interval_new((Real*)real_zero(), true, (Real*)real_zero(), true, (Real*)real_zero());
+    return interval_new(real_zero(), true, real_zero(), true, real_zero());
 }
 
 /*
@@ -202,7 +202,7 @@ Interval* interval_zero ()
  */
 Interval* interval_one ()
 {
-    return interval_new((Real*)real_one(), true, (Real*)real_one(), true, (Real*)real_one());
+    return interval_new(real_one(), true, real_one(), true, real_one());
 }
 
 /*
@@ -211,7 +211,7 @@ Interval* interval_one ()
  */
 Interval* interval_pi ()
 {
-    return (Interval*)interval_new((Real*)real_pi(ROUND_DOWN), false, (Real*)real_pi(ROUND_NEAREST), false, (Real*)real_pi(ROUND_UP1));
+    return interval_new(real_pi(ROUND_DOWN), false, real_pi(ROUND_NEAREST), false, real_pi(ROUND_UP1));
 }
 
 /*
@@ -220,7 +220,7 @@ Interval* interval_pi ()
  */
 Interval* interval_e ()
 {
-    return (Interval*)interval_new((Real*)real_e(ROUND_DOWN), false, (Real*)real_e(ROUND_NEAREST), false, (Real*)real_e(ROUND_UP1));
+    return interval_new(real_e(ROUND_DOWN), false, real_e(ROUND_NEAREST), false, real_e(ROUND_UP1));
 }
 
 /*
@@ -229,7 +229,7 @@ Interval* interval_e ()
  */
 Interval* interval_dup (Interval* interval)
 {
-    return interval_new((Real*)real_dup(interval->l), interval->L, (Real*)real_dup(interval->n), interval->R, (Real*)real_dup(interval->u));
+    return interval_new(real_dup(interval->l), interval->L, real_dup(interval->n), interval->R, real_dup(interval->u));
 }
 
 /*
@@ -243,12 +243,12 @@ Interval* interval_add (Interval* a, Interval* b)
     Real* l;
     Real* u;
     
-    n = (Real*)real_add(a->n, b->n);
-    l = (Real*)real_add(a->l, b->l);
-    u = (Real*)real_add(a->u, b->u);
+    n = real_add(a->n, b->n);
+    l = real_add(a->l, b->l);
+    u = real_add(a->u, b->u);
     
-    L = a->L && b->L;
-    R = a->R && b->R;
+    L = (a->L && b->L);
+    R = (a->R && b->R);
     
     return interval_new(l, L, n, R, u);
 }
@@ -264,12 +264,12 @@ Interval* interval_subtract (Interval* a, Interval* b)
     Real* l;
     Real* u;
     
-    n = (Real*)real_subtract(a->n, b->n);
-    l = (Real*)real_subtract(a->l, b->u);
-    u = (Real*)real_subtract(a->u, b->l);
+    n = real_subtract(a->n, b->n);
+    l = real_subtract(a->l, b->u);
+    u = real_subtract(a->u, b->l);
     
-    L = a->L && b->R;
-    R = a->R && b->L;
+    L = (a->L && b->R);
+    R = (a->R && b->L);
     
     return interval_new(l, L, n, R, u);
 }
@@ -285,20 +285,19 @@ Interval* interval_multiply (Interval* a, Interval* b)
     Real* l;
     Real* u;
     RealBounds* bounds;
-    Interval* interval;
     
-    bounds = (RealBounds*)real_bounds_new();
-    real_bounds_update(bounds, (Real*)real_multiply(a->l, b->l), a->L && b->L);
-    real_bounds_update(bounds, (Real*)real_multiply(a->l, b->u), a->L && b->R);
-    real_bounds_update(bounds, (Real*)real_multiply(a->u, b->l), a->R && b->L);
-    real_bounds_update(bounds, (Real*)real_multiply(a->u, b->u), a->R && b->R);
+    bounds = real_bounds_new();
+    real_bounds_update(bounds, real_multiply(a->l, b->l), (a->L && b->L));
+    real_bounds_update(bounds, real_multiply(a->l, b->u), (a->L && b->R));
+    real_bounds_update(bounds, real_multiply(a->u, b->l), (a->R && b->L));
+    real_bounds_update(bounds, real_multiply(a->u, b->u), (a->R && b->R));
     
-    L = bounds->min_closed;
-    R = bounds->max_closed;
+    L = (bounds->min_closed);
+    R = (bounds->max_closed);
     
-    n = (Real*)real_multiply(a->n, b->n);
-    l = (Real*)real_dup(bounds->min);
-    u = (Real*)real_dup(bounds->max);
+    n = real_multiply(a->n, b->n);
+    l = real_dup(bounds->min);
+    u = real_dup(bounds->max);
     
     real_bounds_free(bounds);
     
@@ -316,24 +315,23 @@ Interval* interval_divide (Interval* a, Interval* b)
     Real* l;
     Real* u;
     RealBounds* bounds;
-    Interval* interval;
     
-    bounds = (RealBounds*)real_bounds_new();
-    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);
-    real_bounds_update(bounds, (Real*)real_divide(a->u, b->u, ROUND_DOWN), a->R && b->R);
-    real_bounds_update(bounds, (Real*)real_divide(a->l, b->l, ROUND_UP), a->L && b->L);
-    real_bounds_update(bounds, (Real*)real_divide(a->l, b->u, ROUND_UP), a->L && b->R);
-    real_bounds_update(bounds, (Real*)real_divide(a->u, b->l, ROUND_UP), a->R && b->L);
-    real_bounds_update(bounds, (Real*)real_divide(a->u, b->u, ROUND_UP), a->R && b->R);
+    bounds = real_bounds_new();
+    real_bounds_update(bounds, real_divide(a->l, b->l, ROUND_DOWN), (a->L && b->L));
+    real_bounds_update(bounds, real_divide(a->l, b->u, ROUND_DOWN), (a->L && b->R));
+    real_bounds_update(bounds, real_divide(a->u, b->l, ROUND_DOWN), (a->R && b->L));
+    real_bounds_update(bounds, real_divide(a->u, b->u, ROUND_DOWN), (a->R && b->R));
+    real_bounds_update(bounds, real_divide(a->l, b->l, ROUND_UP), (a->L && b->L));
+    real_bounds_update(bounds, real_divide(a->l, b->u, ROUND_UP), (a->L && b->R));
+    real_bounds_update(bounds, real_divide(a->u, b->l, ROUND_UP), (a->R && b->L));
+    real_bounds_update(bounds, real_divide(a->u, b->u, ROUND_UP), (a->R && b->R));
     
-    L = bounds->min_closed;
-    R = bounds->max_closed;
+    L = (bounds->min_closed);
+    R = (bounds->max_closed);
     
-    n = (Real*)real_divide(a->n, b->n, ROUND_NEAREST);
-    l = (Real*)real_dup(bounds->min);
-    u = (Real*)real_dup(bounds->max);
+    n = real_divide(a->n, b->n, ROUND_NEAREST);
+    l = real_dup(bounds->min);
+    u = real_dup(bounds->max);
     
     real_bounds_free(bounds);
     
@@ -345,7 +343,7 @@ Interval* interval_divide (Interval* a, Interval* b)
  */
 Interval* interval_negate (Interval* interval)
 {
-    return interval_new((Real*)real_negate(interval->u), interval->R, (Real*)real_negate(interval->n), interval->L, (Real*)real_negate(interval->l));
+    return interval_new(real_negate(interval->u), interval->R, real_negate(interval->n), interval->L, real_negate(interval->l));
 }
 
 /*
@@ -354,7 +352,7 @@ Interval* interval_negate (Interval* interval)
  */
 Interval* interval_round (Interval* interval)
 {
-    return interval_new((Real*)real_round(interval->l), true, (Real*)real_round(interval->n), true, (Real*)real_round(interval->u));
+    return interval_new(real_round(interval->l), true, real_round(interval->n), true, real_round(interval->u));
 }
 
 /*
@@ -364,7 +362,7 @@ Interval* interval_round (Interval* interval)
  */
 Interval* interval_round_ceiling (Interval* interval)
 {
-    return interval_new((Real*)real_ceil(interval->l), true, (Real*)real_ceil(interval->n), true, (Real*)real_ceil(interval->u));
+    return interval_new(real_ceil(interval->l), true, real_ceil(interval->n), true, real_ceil(interval->u));
 }
 
 /*
@@ -374,7 +372,7 @@ Interval* interval_round_ceiling (Interval* interval)
  */
 Interval* interval_round_floor (Interval* interval)
 {
-    return interval_new((Real*)real_floor(interval->l), true, (Real*)real_floor(interval->n), true, (Real*)real_floor(interval->u));
+    return interval_new(real_floor(interval->l), true, real_floor(interval->n), true, real_floor(interval->u));
 }
 
 /*
@@ -384,7 +382,7 @@ Interval* interval_round_floor (Interval* interval)
  */
 Interval* interval_round_infinity (Interval* interval)
 {
-    return interval_new((Real*)real_round_infinity(interval->l), true, (Real*)real_round_infinity(interval->n), true, (Real*)real_round_infinity(interval->u));
+    return interval_new(real_round_infinity(interval->l), true, real_round_infinity(interval->n), true, real_round_infinity(interval->u));
 }
 
 /*
@@ -394,5 +392,5 @@ Interval* interval_round_infinity (Interval* interval)
  */
 Interval* interval_round_origin (Interval* interval)
 {
-    return interval_new((Real*)real_round_origin(interval->l), true, (Real*)real_round_origin(interval->n), true, (Real*)real_round_origin(interval->u));
+    return interval_new(real_round_origin(interval->l), true, real_round_origin(interval->n), true, real_round_origin(interval->u));
 }

data/ext/{number.c → number/number.c}

@@ -6,14 +6,14 @@ VALUE rb_cNumber;
 VALUE rb_NilClass_to_number (VALUE nil)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_nan();
+    DATA_PTR(result) = 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);
+    VALUE complex_regex = rb_reg_new_str(rb_enc_str_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))
@@ -23,7 +23,7 @@ VALUE rb_String_to_number (VALUE str)
     }
     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_regex = rb_reg_new_str(rb_enc_str_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))
@@ -33,44 +33,45 @@ VALUE rb_String_to_number (VALUE str)
         }
         else
         {
-            VALUE real_regex = rb_enc_reg_new("^([+-]?[0-9]+):([+-]?[0-9]+)$", strlen("^([+-]?[0-9]+):([+-]?[0-9]+)$"), rb_utf8_encoding(), 0);
+            VALUE real_regex = rb_reg_new_str(rb_enc_str_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)));
+                VALUE integer = rb_funcall(RARRAY_PTR(real_captures)[1], rb_intern("to_i"), 0);
+                Real* real = real_from_str((char*)RSTRING_PTR(RARRAY_PTR(real_captures)[0]), NUM2LONG(integer));
                 
-                DATA_PTR(result) = (Complex*)complex_from_real(real);
+                DATA_PTR(result) = complex_from_real(real);
                 real_free(real);
                 
                 return result;
             }
-            else if ((long)RSTRING_PTR(str)[0] == -61)
+            else if (RSTRING_PTR(str)[0] == -61)
             {
                 VALUE result = rb_obj_alloc(rb_cNumber);
-                DATA_PTR(result) = (Complex*)complex_nan();
+                DATA_PTR(result) = complex_nan();
                 
                 return result;
             }
-            else if ((long)RSTRING_PTR(str)[0] == -30)
+            else if (RSTRING_PTR(str)[0] == -30)
             {
                 VALUE result = rb_obj_alloc(rb_cNumber);
-                DATA_PTR(result) = (Complex*)complex_pos_inf();
+                DATA_PTR(result) = 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)
+            else if ((RSTRING_PTR(str)[0] == 43 || RSTRING_PTR(str)[0] == 45) && 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();
+                DATA_PTR(result) = (RSTRING_PTR(str)[0] == 43) ? complex_pos_inf() : complex_neg_inf();
                 
                 return result;
             }
             else
             {
-                VALUE integer_regex = rb_enc_reg_new("^([+-]?[0-9]+)$", strlen("^([+-]?[0-9]+)$"), rb_utf8_encoding(), 0);
+                VALUE integer_regex = rb_reg_new_str(rb_enc_str_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))
@@ -92,7 +93,8 @@ VALUE rb_String_to_number (VALUE str)
 VALUE rb_Integer_to_number (VALUE integer)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_from_int_str(RSTRING_PTR(rb_funcall(integer, rb_intern("to_s"), 0)));
+    VALUE str = rb_funcall(integer, rb_intern("to_s"), 0);
+    DATA_PTR(result) = complex_from_int_str((char*)RSTRING_PTR(str));
     
     return result;
 }
@@ -100,7 +102,9 @@ VALUE rb_Integer_to_number (VALUE integer)
 VALUE rb_Float_to_number (VALUE flo)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_from_float_str(RSTRING_PTR(rb_funcall(rb_str_new2("%.15e"), rb_intern("%"), 1, flo)));
+    VALUE str = rb_funcall(rb_str_new2("%.15e"), rb_intern("%"), 1, flo);
+    
+    DATA_PTR(result) = complex_from_float_str((char*)RSTRING_PTR(str));
     
     return result;
 }
@@ -110,11 +114,11 @@ VALUE rb_Complex_to_number (VALUE complex)
     Complex* re;
     Complex* im;
     
-    re = (Complex*)DATA_PTR(rb_convert_type(rb_funcall(complex, rb_intern("real"), 0), T_DATA, "Number", "to_number"));
-    im = (Complex*)DATA_PTR(rb_convert_type(rb_funcall(complex, rb_intern("imag"), 0), T_DATA, "Number", "to_number"));
+    re = DATA_PTR(rb_convert_type(rb_funcall(complex, rb_intern("real"), 0), T_DATA, "Number", "to_number"));
+    im = DATA_PTR(rb_convert_type(rb_funcall(complex, rb_intern("imag"), 0), T_DATA, "Number", "to_number"));
     
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_new((Interval*)interval_dup(re->re), (Interval*)interval_dup(im->re));
+    DATA_PTR(result) = complex_new(interval_dup(re->re), interval_dup(im->re));
     
     return result;
 }
@@ -140,25 +144,25 @@ VALUE rb_f_Number (int argc, VALUE* argv, VALUE obj)
     {
         case 1:
             tmp_A = rb_convert_type(arg1, T_DATA, "Number", "to_number");
-            tmp1 = (Complex*)DATA_PTR(tmp_A);
+            tmp1 = DATA_PTR(tmp_A);
             
-            DATA_PTR(result) = (Complex*)complex_dup(tmp1);
+            DATA_PTR(result) = complex_dup(tmp1);
             break;
         
         case 2:
             tmp_A = rb_convert_type(arg1, T_DATA, "Number", "to_number");
             tmp_B = rb_convert_type(arg2, T_DATA, "Number", "to_number");
             
-            tmp1 = (Complex*)DATA_PTR(tmp_A);
-            tmp2 = (Complex*)DATA_PTR(tmp_B);
+            tmp1 = DATA_PTR(tmp_A);
+            tmp2 = DATA_PTR(tmp_B);
             
-            Interval* re1 = (Interval*)tmp1->re;
-            Interval* re2 = (Interval*)tmp2->re;
+            Interval* re1 = tmp1->re;
+            Interval* re2 = tmp2->re;
             
-            i1 = (Interval*)interval_dup(re1);
-            i2 = (Interval*)interval_dup(re2);
+            i1 = interval_dup(re1);
+            i2 = interval_dup(re2);
             
-            DATA_PTR(result) = (Complex*)complex_new(i1, i2);
+            DATA_PTR(result) = complex_new(i1, i2);
             break;
         
         default:
@@ -166,25 +170,25 @@ VALUE rb_f_Number (int argc, VALUE* argv, VALUE obj)
             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);
+            tmp1 = DATA_PTR(tmp_A);
+            tmp2 = DATA_PTR(tmp_B);
+            tmp3 = DATA_PTR(tmp_C);
             
-            Real* n1 = (Real*)tmp1->re->n;
-            Real* n2 = (Real*)tmp2->re->n;
-            Real* n3 = (Real*)tmp3->re->n;
+            Real* n1 = tmp1->re->n;
+            Real* n2 = tmp2->re->n;
+            Real* n3 = tmp3->re->n;
             
-            Real* r1 = (Real*)real_dup(n1);
-            Real* r2 = (Real*)real_dup(n2);
-            Real* r3 = (Real*)real_dup(n3);
+            Real* r1 = real_dup(n1);
+            Real* r2 = real_dup(n2);
+            Real* r3 = real_dup(n3);
             
             int L = (argc == 3) ? true : RTEST(arg4);
             int R = (argc == 5) ? RTEST(arg5) : L;
             
-            i1 = (Interval*)interval_new(r1, L, r2, R, r3);
-            i2 = (Interval*)interval_zero();
+            i1 = interval_new(r1, L, r2, R, r3);
+            i2 = interval_zero();
             
-            DATA_PTR(result) = (Complex*)complex_new(i1, i2);
+            DATA_PTR(result) = complex_new(i1, i2);
             break;
     }
     
@@ -193,7 +197,6 @@ VALUE rb_f_Number (int argc, VALUE* argv, VALUE obj)
 
 VALUE rb_Number_s_allocate (VALUE klass)
 {
-    void complex_free (Complex*);
     return Data_Wrap_Struct(klass, 0, complex_free, 0);
 }
 
@@ -211,7 +214,7 @@ VALUE rb_Number_s_set_digits (VALUE klass, VALUE n)
 VALUE rb_Number_s_nan (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_nan();
+    DATA_PTR(result) = complex_nan();
     
     return result;
 }
@@ -219,7 +222,7 @@ VALUE rb_Number_s_nan (VALUE klass)
 VALUE rb_Number_s_pos_inf (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_pos_inf();
+    DATA_PTR(result) = complex_pos_inf();
     
     return result;
 }
@@ -227,7 +230,7 @@ VALUE rb_Number_s_pos_inf (VALUE klass)
 VALUE rb_Number_s_neg_inf (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_neg_inf();
+    DATA_PTR(result) = complex_neg_inf();
     
     return result;
 }
@@ -235,7 +238,7 @@ VALUE rb_Number_s_neg_inf (VALUE klass)
 VALUE rb_Number_s_zero (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_zero();
+    DATA_PTR(result) = complex_zero();
     
     return result;
 }
@@ -243,7 +246,7 @@ VALUE rb_Number_s_zero (VALUE klass)
 VALUE rb_Number_s_one (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_one();
+    DATA_PTR(result) = complex_one();
     
     return result;
 }
@@ -251,7 +254,7 @@ VALUE rb_Number_s_one (VALUE klass)
 VALUE rb_Number_s_pi (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_pi();
+    DATA_PTR(result) = complex_pi();
     
     return result;
 }
@@ -259,7 +262,7 @@ VALUE rb_Number_s_pi (VALUE klass)
 VALUE rb_Number_s_e (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_e();
+    DATA_PTR(result) = complex_e();
     
     return result;
 }
@@ -267,7 +270,7 @@ VALUE rb_Number_s_e (VALUE klass)
 VALUE rb_Number_s_i (VALUE klass)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_i();
+    DATA_PTR(result) = complex_i();
     
     return result;
 }
@@ -326,7 +329,7 @@ VALUE rb_Number_to_s (VALUE number)
     
     complex_print(buf, DATA_PTR(number));
     
-    return rb_str_new_cstr(buf);
+    return rb_str_new2(buf);
 }
 
 VALUE rb_Number_dummy (VALUE number)
@@ -342,7 +345,7 @@ VALUE rb_Number_coerce (VALUE a, VALUE b)
 VALUE rb_Number_add (VALUE a, VALUE b)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_add(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
+    DATA_PTR(result) = complex_add(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
     
     return result;
 }
@@ -350,7 +353,7 @@ VALUE rb_Number_add (VALUE a, VALUE b)
 VALUE rb_Number_subtract (VALUE a, VALUE b)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_subtract(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
+    DATA_PTR(result) = complex_subtract(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
     
     return result;
 }
@@ -358,7 +361,7 @@ VALUE rb_Number_subtract (VALUE a, VALUE b)
 VALUE rb_Number_multiply (VALUE a, VALUE b)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_multiply(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
+    DATA_PTR(result) = complex_multiply(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
     
     return result;
 }
@@ -366,7 +369,7 @@ VALUE rb_Number_multiply (VALUE a, VALUE b)
 VALUE rb_Number_divide (VALUE a, VALUE b)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_divide(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
+    DATA_PTR(result) = complex_divide(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
     
     return result;
 }
@@ -374,7 +377,7 @@ VALUE rb_Number_divide (VALUE a, VALUE b)
 VALUE rb_Number_modulo (VALUE a, VALUE b)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_modulo(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
+    DATA_PTR(result) = complex_modulo(DATA_PTR(a), DATA_PTR(rb_convert_type(b, T_DATA, "Number", "to_number")));
     
     return result;
 }
@@ -392,7 +395,7 @@ VALUE rb_Number_eqq_p (VALUE a, VALUE b)
 VALUE rb_Number_abs (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_abs(DATA_PTR(number));
+    DATA_PTR(result) = complex_abs(DATA_PTR(number));
     
     return result;
 }
@@ -400,7 +403,7 @@ VALUE rb_Number_abs (VALUE number)
 VALUE rb_Number_area (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_area(DATA_PTR(number));
+    DATA_PTR(result) = complex_area(DATA_PTR(number));
     
     return result;
 }
@@ -413,7 +416,7 @@ VALUE rb_Number_complex_p (VALUE number)
 VALUE rb_Number_conjugate (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_conjugate(DATA_PTR(number));
+    DATA_PTR(result) = complex_conjugate(DATA_PTR(number));
     
     return result;
 }
@@ -421,7 +424,7 @@ VALUE rb_Number_conjugate (VALUE number)
 VALUE rb_Number_diagonal (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_diagonal(DATA_PTR(number));
+    DATA_PTR(result) = complex_diagonal(DATA_PTR(number));
     
     return result;
 }
@@ -429,7 +432,7 @@ VALUE rb_Number_diagonal (VALUE number)
 VALUE rb_Number_imag (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im(DATA_PTR(number));
+    DATA_PTR(result) = complex_im(DATA_PTR(number));
     
     return result;
 }
@@ -437,7 +440,7 @@ VALUE rb_Number_imag (VALUE number)
 VALUE rb_Number_negate (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_negate(DATA_PTR(number));
+    DATA_PTR(result) = complex_negate(DATA_PTR(number));
     
     return result;
 }
@@ -445,7 +448,7 @@ VALUE rb_Number_negate (VALUE number)
 VALUE rb_Number_real (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re(DATA_PTR(number));
+    DATA_PTR(result) = complex_re(DATA_PTR(number));
     
     return result;
 }
@@ -458,7 +461,7 @@ VALUE rb_Number_real_p (VALUE number)
 VALUE rb_Number_reflect (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_reflect(DATA_PTR(number));
+    DATA_PTR(result) = complex_reflect(DATA_PTR(number));
     
     return result;
 }
@@ -466,7 +469,7 @@ VALUE rb_Number_reflect (VALUE number)
 VALUE rb_Number_round (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round(DATA_PTR(number));
+    DATA_PTR(result) = complex_round(DATA_PTR(number));
     
     return result;
 }
@@ -474,7 +477,7 @@ VALUE rb_Number_round (VALUE number)
 VALUE rb_Number_sqrt (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_sqrt(DATA_PTR(number));
+    DATA_PTR(result) = complex_sqrt(DATA_PTR(number));
     
     return result;
 }
@@ -482,7 +485,7 @@ VALUE rb_Number_sqrt (VALUE number)
 VALUE rb_Number_round_c_c (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_c_c(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_c_c(DATA_PTR(number));
     
     return result;
 }
@@ -490,7 +493,7 @@ VALUE rb_Number_round_c_c (VALUE number)
 VALUE rb_Number_round_c_f (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_c_f(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_c_f(DATA_PTR(number));
     
     return result;
 }
@@ -498,7 +501,7 @@ VALUE rb_Number_round_c_f (VALUE number)
 VALUE rb_Number_round_f_c (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_f_c(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_f_c(DATA_PTR(number));
     
     return result;
 }
@@ -506,7 +509,7 @@ VALUE rb_Number_round_f_c (VALUE number)
 VALUE rb_Number_round_f_f (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_f_f(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_f_f(DATA_PTR(number));
     
     return result;
 }
@@ -514,7 +517,7 @@ VALUE rb_Number_round_f_f (VALUE number)
 VALUE rb_Number_round_i_i (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_i_i(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_i_i(DATA_PTR(number));
     
     return result;
 }
@@ -522,7 +525,7 @@ VALUE rb_Number_round_i_i (VALUE number)
 VALUE rb_Number_round_i_o (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_i_o(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_i_o(DATA_PTR(number));
     
     return result;
 }
@@ -530,7 +533,7 @@ VALUE rb_Number_round_i_o (VALUE number)
 VALUE rb_Number_round_o_i (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_o_i(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_o_i(DATA_PTR(number));
     
     return result;
 }
@@ -538,7 +541,7 @@ VALUE rb_Number_round_o_i (VALUE number)
 VALUE rb_Number_round_o_o (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_round_o_o(DATA_PTR(number));
+    DATA_PTR(result) = complex_round_o_o(DATA_PTR(number));
     
     return result;
 }
@@ -546,7 +549,7 @@ VALUE rb_Number_round_o_o (VALUE number)
 VALUE rb_Number_complex_ll (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_ll(DATA_PTR(number));
+    DATA_PTR(result) = complex_ll(DATA_PTR(number));
     
     return result;
 }
@@ -554,7 +557,7 @@ VALUE rb_Number_complex_ll (VALUE number)
 VALUE rb_Number_complex_lu (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_lu(DATA_PTR(number));
+    DATA_PTR(result) = complex_lu(DATA_PTR(number));
     
     return result;
 }
@@ -562,7 +565,7 @@ VALUE rb_Number_complex_lu (VALUE number)
 VALUE rb_Number_complex_n (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_n(DATA_PTR(number));
+    DATA_PTR(result) = complex_n(DATA_PTR(number));
     
     return result;
 }
@@ -570,7 +573,7 @@ VALUE rb_Number_complex_n (VALUE number)
 VALUE rb_Number_complex_ul (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_ul(DATA_PTR(number));
+    DATA_PTR(result) = complex_ul(DATA_PTR(number));
     
     return result;
 }
@@ -578,7 +581,7 @@ VALUE rb_Number_complex_ul (VALUE number)
 VALUE rb_Number_complex_uu (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_uu(DATA_PTR(number));
+    DATA_PTR(result) = complex_uu(DATA_PTR(number));
     
     return result;
 }
@@ -586,7 +589,7 @@ VALUE rb_Number_complex_uu (VALUE number)
 VALUE rb_Number_complex_magnitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_magnitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_magnitude(DATA_PTR(number));
     
     return result;
 }
@@ -594,7 +597,7 @@ VALUE rb_Number_complex_magnitude (VALUE number)
 VALUE rb_Number_complex_mignitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_mignitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_mignitude(DATA_PTR(number));
     
     return result;
 }
@@ -602,7 +605,7 @@ VALUE rb_Number_complex_mignitude (VALUE number)
 VALUE rb_Number_complex_width (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_width(DATA_PTR(number));
+    DATA_PTR(result) = complex_width(DATA_PTR(number));
     
     return result;
 }
@@ -610,7 +613,7 @@ VALUE rb_Number_complex_width (VALUE number)
 VALUE rb_Number_imag_l (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_l(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_l(DATA_PTR(number));
     
     return result;
 }
@@ -618,7 +621,7 @@ VALUE rb_Number_imag_l (VALUE number)
 VALUE rb_Number_imag_n (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_n(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_n(DATA_PTR(number));
     
     return result;
 }
@@ -626,7 +629,7 @@ VALUE rb_Number_imag_n (VALUE number)
 VALUE rb_Number_imag_u (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_u(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_u(DATA_PTR(number));
     
     return result;
 }
@@ -634,7 +637,7 @@ VALUE rb_Number_imag_u (VALUE number)
 VALUE rb_Number_imag_magnitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_magnitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_magnitude(DATA_PTR(number));
     
     return result;
 }
@@ -642,7 +645,7 @@ VALUE rb_Number_imag_magnitude (VALUE number)
 VALUE rb_Number_imag_mignitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_mignitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_mignitude(DATA_PTR(number));
     
     return result;
 }
@@ -650,7 +653,7 @@ VALUE rb_Number_imag_mignitude (VALUE number)
 VALUE rb_Number_imag_width (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_im_width(DATA_PTR(number));
+    DATA_PTR(result) = complex_im_width(DATA_PTR(number));
     
     return result;
 }
@@ -658,7 +661,7 @@ VALUE rb_Number_imag_width (VALUE number)
 VALUE rb_Number_real_l (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_l(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_l(DATA_PTR(number));
     
     return result;
 }
@@ -666,7 +669,7 @@ VALUE rb_Number_real_l (VALUE number)
 VALUE rb_Number_real_n (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_n(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_n(DATA_PTR(number));
     
     return result;
 }
@@ -674,7 +677,7 @@ VALUE rb_Number_real_n (VALUE number)
 VALUE rb_Number_real_u (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_u(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_u(DATA_PTR(number));
     
     return result;
 }
@@ -682,7 +685,7 @@ VALUE rb_Number_real_u (VALUE number)
 VALUE rb_Number_real_magnitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_magnitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_magnitude(DATA_PTR(number));
     
     return result;
 }
@@ -690,7 +693,7 @@ VALUE rb_Number_real_magnitude (VALUE number)
 VALUE rb_Number_real_mignitude (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_mignitude(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_mignitude(DATA_PTR(number));
     
     return result;
 }
@@ -698,7 +701,7 @@ VALUE rb_Number_real_mignitude (VALUE number)
 VALUE rb_Number_real_width (VALUE number)
 {
     VALUE result = rb_obj_alloc(rb_cNumber);
-    DATA_PTR(result) = (Complex*)complex_re_width(DATA_PTR(number));
+    DATA_PTR(result) = complex_re_width(DATA_PTR(number));
     
     return result;
 }