number 0.9.10 → 0.9.11

data/ext/number/bounds.c

@@ -29,6 +29,30 @@ void bounds_free (Bounds* bounds)
     }
 }
 
+Bounds* bounds_new ()
+{
+    Bounds* bounds = malloc(sizeof(Bounds));
+    
+    if (bounds == NULL)
+    {
+        return NULL;
+    }
+    
+    memset(bounds, 0, sizeof(Bounds));
+    
+    mpfr_init2(bounds->re_min, PREC);
+    mpfr_init2(bounds->re_max, PREC);
+    mpfr_init2(bounds->im_min, PREC);
+    mpfr_init2(bounds->im_max, PREC);
+    
+    mpfr_set_inf(bounds->re_min, 1);
+    mpfr_set_inf(bounds->re_max, -1);
+    mpfr_set_inf(bounds->im_min, 1);
+    mpfr_set_inf(bounds->im_max, -1);
+    
+    return bounds;
+}
+
 void bounds_update_re (Bounds* bounds, mpfr_t num, int re_closed, int exact)
 {
     int min_cmp = mpfr_cmp(bounds->re_min, num);
@@ -84,27 +108,3 @@ void bounds_update (Bounds* bounds, mpc_t num, int re_closed, int im_closed, int
     mpfr_clear(re);
     mpfr_clear(im);
 }
-
-Bounds* bounds_new ()
-{
-    Bounds* bounds = malloc(sizeof(Bounds));
-    
-    if (bounds == NULL)
-    {
-        return NULL;
-    }
-    
-    memset(bounds, 0, sizeof(Bounds));
-    
-    mpfr_init2(bounds->re_min, PREC);
-    mpfr_init2(bounds->re_max, PREC);
-    mpfr_init2(bounds->im_min, PREC);
-    mpfr_init2(bounds->im_max, PREC);
-    
-    mpfr_set_inf(bounds->re_min, 1);
-    mpfr_set_inf(bounds->re_max, -1);
-    mpfr_set_inf(bounds->im_min, 1);
-    mpfr_set_inf(bounds->im_max, -1);
-    
-    return bounds;
-}

data/ext/number/complex.c

@@ -150,34 +150,46 @@ void complex_free (Complex* complex)
 }
 
 /*
- *  Returns the maximum size of the string representation of complex as a long.
+ *  Returns the size of the string representation of complex as a long.
  */
 long complex_strlen (Complex* complex)
 {
-    return (interval_strlen(complex->re) + interval_strlen(complex->im) + 10);
+    if (interval_zero_p(complex->im))
+    {
+        return interval_strlen(complex->re);
+    }
+    else
+    {
+        int sign = 1;
+        int i = 1;
+        int re = interval_strlen(complex->re);
+        int im = interval_strlen(complex->im);
+        
+        return re + sign + im + i;
+    }
 }
 
 /*
  *  Puts a string representation of complex into the string pointed to by buf.
  *  
- *    complex: ({1:1 < 2:1 < 3:1},{0:1 ≤ 0:1 ≤ 0:1}) => str: "{1:1 < 2:1 < 3:1}, {0:1 ≤ 0:1 ≤ 0:1}i"
+ *    complex: [1:1 < (2:1) < 3:1]+[0:0 ≤ (0:0) ≤ 0:0]i => str: "[1:1 < (2:1) < 3:1]"
+ *    complex: [1:1 < (2:1) < 3:1]+[1:0 ≤ (1:0) ≤ 1:0]i => str: "[1:1 < (2:1) < 3:1]+1:0i"
  */
 void complex_print (char* buf, Complex* complex)
 {
-    char rbuf[interval_strlen(complex->re)];
-    char ibuf[interval_strlen(complex->im)];
-    
     if (interval_zero_p(complex->im))
     {
-        interval_print(rbuf, complex->re);
-        sprintf(buf, "%s", rbuf);
+        interval_print(buf, complex->re);
     }
     else
     {
-        interval_print(rbuf, complex->re);
-        interval_print(ibuf, complex->im);
+        char re_buf[interval_strlen(complex->re)];
+        char im_buf[interval_strlen(complex->im)];
+        
+        interval_print(re_buf, complex->re);
+        interval_print(im_buf, complex->im);
         
-        sprintf(buf, "%s+%si", rbuf, ibuf);
+        sprintf(buf, "%s+%si", re_buf, im_buf);
     }
 }
 

data/ext/number/decompose.c

@@ -162,40 +162,40 @@ Complex* complex_re_width (Complex* complex)
 
 Complex* complex_ll (Complex* complex)
 {
-    Interval* re = interval_from_real(complex->re->l);
-    Interval* im = interval_from_real(complex->im->l);
+    Interval* re = interval_from_real(real_dup(complex->re->l));
+    Interval* im = interval_from_real(real_dup(complex->im->l));
     
     return complex_new(re, im);
 }
 
 Complex* complex_lu (Complex* complex)
 {
-    Interval* re = interval_from_real(complex->re->l);
-    Interval* im = interval_from_real(complex->im->u);
+    Interval* re = interval_from_real(real_dup(complex->re->l));
+    Interval* im = interval_from_real(real_dup(complex->im->u));
     
     return complex_new(re, im);
 }
 
 Complex* complex_n (Complex* complex)
 {
-    Interval* re = interval_from_real(complex->re->n);
-    Interval* im = interval_from_real(complex->im->n);
+    Interval* re = interval_from_real(real_dup(complex->re->n));
+    Interval* im = interval_from_real(real_dup(complex->im->n));
     
     return complex_new(re, im);
 }
 
 Complex* complex_ul (Complex* complex)
 {
-    Interval* re = interval_from_real(complex->re->u);
-    Interval* im = interval_from_real(complex->im->l);
+    Interval* re = interval_from_real(real_dup(complex->re->u));
+    Interval* im = interval_from_real(real_dup(complex->im->l));
     
     return complex_new(re, im);
 }
 
 Complex* complex_uu (Complex* complex)
 {
-    Interval* re = interval_from_real(complex->re->u);
-    Interval* im = interval_from_real(complex->im->u);
+    Interval* re = interval_from_real(real_dup(complex->re->u));
+    Interval* im = interval_from_real(real_dup(complex->im->u));
     
     return complex_new(re, im);
 }

data/ext/number/interval.c

@@ -28,37 +28,53 @@ void interval_free (Interval* interval)
 }
 
 /*
- *  Returns the maximum size of the string representation of interval as a long.
+ *  Returns the size of the string representation of interval as a long.
  */
 long interval_strlen (Interval* interval)
 {
-    return real_strlen(interval->l) + real_strlen(interval->n) + real_strlen(interval->u) + 10;
+    if (interval_degenerate_p(interval))
+    {
+        return real_strlen(interval->n);
+    }
+    else
+    {
+        int cmp = 1;
+        int space = 1;
+        int bracket = 1;
+        int l = real_strlen(interval->l);
+        int n = real_strlen(interval->n);
+        int u = real_strlen(interval->u);
+        
+        return bracket + l + space + cmp + space + bracket + n + bracket + space + cmp + space + u + bracket;
+    }
 }
 
 /*
  *  Puts a string representation of interval into the string pointed to by buf.
  *  
- *    interval: {1:1 < 2:1 < 3:1} => str: "{1:1 < 2:1 < 3:1}"
- *    interval: {0:1 ≤ 0:1 ≤ 0:1} => str: "{0:1 ≤ 0:1 ≤ 0:1}"
+ *    interval: [1:1 < (2:1) < 3:1] => str: "[1:1 < (2:1) < 3:1]"
+ *    interval: [0:0 ≤ (0:0) ≤ 0:0] => str: "0:0"
  */
 void interval_print(char* buf, Interval* interval)
 {
-    char n_str[real_strlen(interval->n)];
-    char l_str[real_strlen(interval->l)];
-    char u_str[real_strlen(interval->u)];
-    
     if (interval_degenerate_p(interval))
     {
-        real_print(n_str, interval->n);
-        sprintf(buf, "%s", n_str);
+        real_print(buf, interval->n);
     }
     else
     {
-        real_print(n_str, interval->n);
-        real_print(l_str, interval->l);
-        real_print(u_str, interval->u);
+        char* L = (interval->L) ? "≤" : "<";
+        char* R = (interval->R) ? "≤" : "<";
+        
+        char l[real_strlen(interval->l)];
+        char n[real_strlen(interval->n)];
+        char u[real_strlen(interval->u)];
         
-        sprintf(buf, "[%s %s (%s) %s %s]", l_str, interval->L ? "≤" : "<", n_str, interval->R ? "≤" : "<", u_str);
+        real_print(l, interval->l);
+        real_print(n, interval->n);
+        real_print(u, interval->u);
+        
+        sprintf(buf, "[%s %s (%s) %s %s]", l, L, n, R, u);
     }
 }
 
@@ -75,12 +91,7 @@ int interval_span_p (Interval* interval, Real* real)
  */
 int interval_span_zero_p (Interval* interval)
 {
-    Real* zero = real_zero();
-    int result = interval_span_p(interval, zero);
-    
-    real_free(zero);
-    
-    return result;
+    return (interval->L && ZERO(interval->l)) || (interval->R && ZERO(interval->u)) || (NEG(interval->l) && POS(interval->u));
 }
 
 /*

data/ext/number/number.c

@@ -44,7 +44,6 @@ VALUE rb_String_to_number (VALUE str)
                 Real* real = real_from_str((char*)RSTRING_PTR(RARRAY_PTR(real_captures)[0]), NUM2LONG(integer));
                 
                 DATA_PTR(result) = complex_from_real(real);
-                real_free(real);
                 
                 return result;
             }
@@ -291,6 +290,11 @@ VALUE rb_Number_initialize_copy (VALUE number, VALUE copy)
     return Qnil; /* not reached */
 }
 
+VALUE rb_Number_to_c (VALUE number)
+{
+    /* TODO */
+}
+
 VALUE rb_Number_to_f (VALUE number)
 {
     if (complex_re_normal_p(DATA_PTR(number)))
@@ -323,6 +327,22 @@ VALUE rb_Number_to_i (VALUE number)
     }
 }
 
+VALUE rb_Number_to_int (VALUE number)
+{
+    if (complex_re_normal_p(DATA_PTR(number)))
+    {
+        char buf[10000];
+        
+        complex_print_int(buf, DATA_PTR(number));
+        
+        return rb_cstr_to_inum(buf, 10, false);
+    }
+    else
+    {
+        return INT2FIX(0);
+    }
+}
+
 VALUE rb_Number_to_s (VALUE number)
 {
     char buf[1000];
@@ -1456,6 +1476,7 @@ void Init_number ()
     
     rb_define_method(rb_cNumber, "to_f", rb_Number_to_f, 0);
     rb_define_method(rb_cNumber, "to_i", rb_Number_to_i, 0);
+    rb_define_method(rb_cNumber, "to_int", rb_Number_to_int, 0);
     rb_define_method(rb_cNumber, "to_s", rb_Number_to_s, 0);
     rb_define_method(rb_cNumber, "to_number", rb_Number_dummy, 0);
     rb_define_method(rb_cNumber, "coerce", rb_Number_coerce, 1);

data/ext/number/number.h

@@ -25,14 +25,15 @@
 #define true 1
 #define false 0
 
-#define NaN_FLAG 1
+#define NAN_FLAG 1
 #define POS_INF_FLAG 2
 #define NEG_INF_FLAG 3
+#define REAL_FLAG 4
 
-#define REAL(real) ((real)->flag == 0)
-#define NaN(real) ((real)->flag == NaN_FLAG)
+#define NaN(real) ((real)->flag == NAN_FLAG)
 #define POS_INF(real) ((real)->flag == POS_INF_FLAG)
 #define NEG_INF(real) ((real)->flag == NEG_INF_FLAG)
+#define REAL(real) ((real)->flag == REAL_FLAG)
 
 #define ZERO(real) (REAL(real) && (mpz_sgn((real)->num) == 0))
 #define POS(real) (POS_INF(real) || (REAL(real) && (mpz_sgn((real)->num) == 1)))

data/ext/number/real.c

@@ -53,30 +53,30 @@ void init_real_tmp_nums ()
 }
 
 /*
- *  Pads num with pow additional zeros.
+ *  Pads num with n additional zeros.
  *  
- *    num: (1234), pow: 2 => num: (123400)
+ *    num: (1234), n: 2 => num: (123400)
  */
-void num_pad (mpz_t num, int pow)
+void num_pad (mpz_t num, int n)
 {
-    mpz_ui_pow_ui(tmp_num_pad, 10, pow);
+    mpz_ui_pow_ui(tmp_num_pad, 10, n);
     mpz_mul(num, num, tmp_num_pad);
 }
 
 /*
- *  Truncates num by overrun digits, rounding the rightmost remaining digit
+ *  Truncates num by n digits, rounding the rightmost remaining digit
  *  using round_mode.
  *  
- *      num: (12345), overrun: 3, round_mode: ROUND_UP => num: (13)
+ *      num: (12345), n: 3, round_mode: ROUND_UP => num: (13)
  */
-void num_round (mpz_t num, int overrun, int round_mode)
+void num_round (mpz_t num, int n, int round_mode)
 {
-    if (!overrun)
+    if (n <= 0)
     {
         return;
     }
     
-    mpz_ui_pow_ui(tmp_num_round, 10, overrun);
+    mpz_ui_pow_ui(tmp_num_round, 10, n);
     
     switch (round_mode)
     {
@@ -90,7 +90,7 @@ void num_round (mpz_t num, int overrun, int round_mode)
         
         case ROUND_NEAREST:
         // fix this
-            //mpz_ui_pow_ui(tmp_num_round, 10, overrun);
+            //mpz_ui_pow_ui(tmp_num_round, 10, n);
             mpz_fdiv_q(num, num, tmp_num_round);
             //mpz_sub_ui(num, num, 5);
             //mpz_fdiv_q_ui(num, num, 10);
@@ -111,10 +111,12 @@ void num_round (mpz_t num, int overrun, int round_mode)
  */
 long num_len (mpz_t num)
 {
-    char buf[mpz_sizeinbase(num, 10) + 2];
+    int base = 10;
+    int sign = (mpz_sgn(num) == -1);
+    char buf[mpz_sizeinbase(num, base) + sign + 1];
     
-    mpz_get_str(buf, 10, num);
-    return strlen(buf) - (mpz_sgn(num) == -1);
+    mpz_get_str(buf, base, num);
+    return strlen(buf) - sign;
 }
 
 /*
@@ -135,11 +137,30 @@ void real_free (Real* real)
 }
 
 /*
- *  Returns the maximum size of the string representation of real as a long.
+ *  Returns the size of the string representation of real as a long.
  */
 long real_strlen (Real* real)
 {
-    return REAL(real) ? mpz_sizeinbase(real->num, 10) + 50 : 10;
+    switch (real->flag)
+    {
+        case NAN_FLAG:
+            return 2;
+        
+        case POS_INF_FLAG:
+        case NEG_INF_FLAG:
+            return 4;
+        
+        case REAL_FLAG:;
+            char buf[100];
+            sprintf(buf, "%ld", real->exp);
+            
+            int sign = (mpz_sgn(real->num) == -1);
+            int digits = num_len(real->num);
+            int colon = 1;
+            int exp = strlen(buf);
+            
+            return sign + digits + colon + exp;
+    }
 }
 
 /*
@@ -147,19 +168,34 @@ long real_strlen (Real* real)
  *  
  *    real: (561:1) => str: "561:1"
  *    real: (-3:-2) => str: "-3:-2"
+ *    real: (+∞)    => str: "+∞"
+ *    real: (ø)     => str: "ø"
  */
 void real_print (char* buf, Real* real)
 {
-    char num_buf[real_strlen(real)];
-    
-    if (!REAL(real))
+    switch (real->flag)
     {
-        sprintf(buf, "%s", NaN(real) ? "ø" : POS_INF(real) ? "+∞" : "-∞");
-        return;
+        case NAN_FLAG:
+            sprintf(buf, "ø");
+            break;
+        
+        case POS_INF_FLAG:
+            sprintf(buf, "+∞");
+            break;
+        
+        case NEG_INF_FLAG:
+            sprintf(buf, "-∞");
+            break;
+        
+        case REAL_FLAG:;
+            int base = 10;
+            int sign = 1;
+            char num_buf[num_len(real->num) + sign + 1];
+            
+            mpz_get_str(num_buf, base, real->num);
+            sprintf(buf, "%s:%ld", num_buf, real->exp);
+            break;
     }
-    
-    mpz_get_str(num_buf, 10, real->num);
-    sprintf(buf, "%s:%ld", num_buf, real->exp);
 }
 
 /*
@@ -192,8 +228,15 @@ void real_pad_tmps (Real* a, Real* b, long* exp, long* len)
         num_pad(b_tmp, -pad);
     }
     
-    *exp = max(a->exp, b->exp);
-    *len = max(a_len, b_len);
+    if (exp != NULL)
+    {
+        *exp = max(a->exp, b->exp);
+    }
+    
+    if (len != NULL)
+    {
+        *len = max(a_len, b_len);
+    }
 }
 
 /*
@@ -225,9 +268,6 @@ int real_positive_p (Real* real)
  */
 int real_cmp (Real* a, Real* b)
 {
-    long exp;
-    long len;
-    
     if (!REAL(a) || !REAL(b))
     {
         return (NaN(a) || NaN(b)) ? 0 : POS_INF(a) ? (POS_INF(b) ? 0 : 1) : POS_INF(b) ? -1 : NEG_INF(a) ? (NEG_INF(b) ? 0 : -1) : 1;
@@ -245,7 +285,7 @@ int real_cmp (Real* a, Real* b)
         return (a_sign == -1) ? ((a->exp < b->exp) ? 1 : -1) : ((a->exp > b->exp) ? 1 : -1);
     }
     
-    real_pad_tmps(a, b, &exp, &len);
+    real_pad_tmps(a, b, NULL, NULL);
     
     return mpz_cmp(a_tmp, b_tmp);
 }
@@ -310,9 +350,9 @@ Real* real_alloc ()
 /*
  *  Returns a pointer to a newly allocated Real representing NaN, +∞, or -∞.
  *  
- *    flag: NaN_FLAG => real: (ø)
+ *    flag: NAN_FLAG => real: (ø)
  *    flag: POS_INF_FLAG => real: (+∞)
- *    flag: NEG__FLAG => real: (-∞)
+ *    flag: NEG_INF_FLAG => real: (-∞)
  */
 Real* real_new_flagged (int flag)
 {
@@ -329,7 +369,7 @@ Real* real_new_flagged (int flag)
  *  any trailing zero digits.
  *  
  *    num: (123), exp: 3 => real: (123:3)
- *    num: (-234), exp: 3 => real: (-234:3)
+ *    num: (-234), exp: 5 => real: (-234:5)
  *    num: (1000), exp: 4 => real: (1:4)
  */
 Real* real_new_exact (mpz_t num, long exp)
@@ -337,7 +377,7 @@ Real* real_new_exact (mpz_t num, long exp)
     Real* real = real_alloc();
     
     real->exp = exp;
-    real->flag = 0;
+    real->flag = REAL_FLAG;
     
     mpz_init(real->num);
     
@@ -376,11 +416,9 @@ Real* real_new_exact (mpz_t num, long exp)
  */
 Real* real_new_rounded (mpz_t num, long exp, int round_mode)
 {
+    long overrun = num_len(num) - digs;
     mpz_set(tmp_real_new_rounded, num);
     
-    long len = num_len(num);
-    long overrun = len - digs;
-    
     if (overrun > 0)
     {
         num_round(tmp_real_new_rounded, overrun, round_mode);
@@ -391,14 +429,17 @@ Real* real_new_rounded (mpz_t num, long exp, int round_mode)
 
 /*
  *  Returns a pointer to a newly allocated Real with the value represented by
- *  the given string and exp.
+ *  the given string and exp. The string must contain only an optional negative
+ *  followed by one or more digits between 0 and 9.
  *  
  *    str: "3456", exp: 2 => real: (3456:2)
  *    str: "-234", exp: -1 => real: (-234:-1)
  */
 Real* real_from_str (char* num_str, long exp)
 {
-    mpz_set_str(tmp_real_from_str, num_str, 10);
+    int base = 10;
+    mpz_set_str(tmp_real_from_str, num_str, base);
+    
     return real_new_exact(tmp_real_from_str, exp);
 }
 
@@ -409,16 +450,19 @@ Real* real_from_str (char* num_str, long exp)
  */
 Real* real_from_mpfr (mpfr_t num, int round_mode)
 {
-    char buf[10000];
-    mpfr_exp_t exp;
-    
     if (!mpfr_number_p(num))
     {
-        return real_new_flagged(mpfr_nan_p(num) ? NaN_FLAG : (mpfr_sgn(num) == 1) ? POS_INF_FLAG : NEG_INF_FLAG);
+        return real_new_flagged(mpfr_nan_p(num) ? NAN_FLAG : (mpfr_sgn(num) == 1) ? POS_INF_FLAG : NEG_INF_FLAG);
     }
     
-    mpfr_get_str(buf, &exp, 10, digs + 5, num, MPFR_RNDN);
-    mpz_set_str(tmp_real_from_mpfr, buf, 10);
+    mpfr_exp_t exp;
+    int base = 10;
+    int sign = 1;
+    int digits = digs + 5;
+    char buf[digits + sign + 1];
+    
+    mpfr_get_str(buf, &exp, base, digits, num, MPFR_RNDN);
+    mpz_set_str(tmp_real_from_mpfr, buf, base);
     
     return real_new_rounded(tmp_real_from_mpfr, (long)exp, round_mode);
 }
@@ -428,7 +472,7 @@ Real* real_from_mpfr (mpfr_t num, int round_mode)
  */
 Real* real_nan ()
 {
-    return real_new_flagged(NaN_FLAG);
+    return real_new_flagged(NAN_FLAG);
 }
 
 /*

data/ext/number/real_bounds.c

@@ -19,6 +19,23 @@ void real_bounds_free (RealBounds* bounds)
     }
 }
 
+RealBounds* real_bounds_new ()
+{
+    RealBounds* bounds = malloc(sizeof(RealBounds));
+    
+    if (bounds == NULL)
+    {
+        return NULL;
+    }
+    
+    memset(bounds, 0, sizeof(RealBounds));
+    
+    bounds->min = real_pos_inf();
+    bounds->max = real_neg_inf();
+    
+    return bounds;
+}
+
 void real_bounds_update (RealBounds* bounds, Real* real, int closed)
 {
     int min_cmp;
@@ -42,20 +59,3 @@ void real_bounds_update (RealBounds* bounds, Real* real, int closed)
     
     real_free(real);
 }
-
-RealBounds* real_bounds_new ()
-{
-    RealBounds* bounds = malloc(sizeof(RealBounds));
-    
-    if (bounds == NULL)
-    {
-        return NULL;
-    }
-    
-    memset(bounds, 0, sizeof(RealBounds));
-    
-    bounds->min = real_pos_inf();
-    bounds->max = real_neg_inf();
-    
-    return bounds;
-}

metadata

@@ -2,7 +2,7 @@
 name: number
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.10
+  version: 0.9.11
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-02 00:00:00 Z
+date: 2011-10-19 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.